diff --git a/.depend b/.depend
index 5262e32be9706bc90d1ada4b134c0d19214162a1..d8ec3bd6e4c2709cafd4caa2e35766cbbc5c5d02 100644
--- a/.depend
+++ b/.depend
@@ -6,64 +6,76 @@ lib/Iteration.vo: lib/Iteration.v lib/Coqlib.vo
lib/Integers.vo: lib/Integers.v lib/Coqlib.vo
lib/Floats.vo: lib/Floats.v lib/Coqlib.vo lib/Integers.vo
lib/Parmov.vo: lib/Parmov.v lib/Coqlib.vo
-common/AST.vo: common/AST.v lib/Coqlib.vo lib/Integers.vo lib/Floats.vo
+common/Errors.vo: common/Errors.v lib/Coqlib.vo
+common/AST.vo: common/AST.v lib/Coqlib.vo common/Errors.vo lib/Integers.vo lib/Floats.vo
common/Events.vo: common/Events.v lib/Coqlib.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo
-common/Globalenvs.vo: common/Globalenvs.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo
+common/Globalenvs.vo: common/Globalenvs.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo
common/Mem.vo: common/Mem.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo
common/Values.vo: common/Values.v lib/Coqlib.vo common/AST.vo lib/Integers.vo lib/Floats.vo
-common/Main.vo: common/Main.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Values.vo cfrontend/Csyntax.vo cfrontend/Csem.vo cfrontend/Csharpminor.vo backend/Cminor.vo backend/RTL.vo backend/LTL.vo backend/Linear.vo backend/Mach.vo backend/PPC.vo cfrontend/Cshmgen.vo cfrontend/Cminorgen.vo backend/RTLgen.vo backend/Constprop.vo backend/CSE.vo backend/Allocation.vo backend/Tunneling.vo backend/Linearize.vo backend/Stacking.vo backend/PPCgen.vo cfrontend/Ctyping.vo backend/RTLtyping.vo backend/LTLtyping.vo backend/Lineartyping.vo backend/Machtyping.vo cfrontend/Cshmgenproof3.vo cfrontend/Cminorgenproof.vo backend/RTLgenproof.vo backend/Constpropproof.vo backend/CSEproof.vo backend/Allocproof.vo backend/Alloctyping.vo backend/Tunnelingproof.vo backend/Tunnelingtyping.vo backend/Linearizeproof.vo backend/Linearizetyping.vo backend/Stackingproof.vo backend/Stackingtyping.vo backend/Machabstr2mach.vo backend/PPCgenproof.vo
+common/Smallstep.vo: common/Smallstep.v lib/Coqlib.vo common/AST.vo common/Events.vo common/Globalenvs.vo lib/Integers.vo
+common/Switch.vo: common/Switch.v lib/Coqlib.vo lib/Integers.vo
+common/Main.vo: common/Main.v lib/Coqlib.vo lib/Maps.vo common/Errors.vo common/AST.vo common/Values.vo common/Smallstep.vo cfrontend/Csyntax.vo cfrontend/Csem.vo cfrontend/Csharpminor.vo backend/Cminor.vo backend/CminorSel.vo backend/RTL.vo backend/LTL.vo backend/LTLin.vo backend/Linear.vo backend/Mach.vo backend/PPC.vo cfrontend/Cshmgen.vo cfrontend/Cminorgen.vo backend/Selection.vo backend/RTLgen.vo backend/Constprop.vo backend/CSE.vo backend/Allocation.vo backend/Tunneling.vo backend/Linearize.vo backend/Reload.vo backend/Stacking.vo backend/PPCgen.vo cfrontend/Ctyping.vo backend/RTLtyping.vo backend/LTLtyping.vo backend/LTLintyping.vo backend/Lineartyping.vo backend/Machtyping.vo cfrontend/Cshmgenproof3.vo cfrontend/Cminorgenproof.vo backend/Selectionproof.vo backend/RTLgenproof.vo backend/Constpropproof.vo backend/CSEproof.vo backend/Allocproof.vo backend/Alloctyping.vo backend/Tunnelingproof.vo backend/Tunnelingtyping.vo backend/Linearizeproof.vo backend/Linearizetyping.vo backend/Reloadproof.vo backend/Reloadtyping.vo backend/Stackingproof.vo backend/Stackingtyping.vo backend/Machabstr2concr.vo backend/PPCgenproof.vo
+backend/Cminor.vo: backend/Cminor.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Events.vo common/Values.vo common/Mem.vo common/Globalenvs.vo common/Switch.vo
backend/Op.vo: backend/Op.v lib/Coqlib.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Globalenvs.vo
-backend/Cminor.vo: backend/Cminor.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Events.vo common/Values.vo common/Mem.vo backend/Op.vo common/Globalenvs.vo
-backend/Cmconstr.vo: backend/Cmconstr.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo backend/Op.vo common/Globalenvs.vo backend/Cminor.vo
-backend/Cmconstrproof.vo: backend/Cmconstrproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo backend/Op.vo common/Globalenvs.vo backend/Cminor.vo backend/Cmconstr.vo
+backend/CminorSel.vo: backend/CminorSel.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Events.vo common/Values.vo common/Mem.vo backend/Cminor.vo backend/Op.vo common/Globalenvs.vo common/Switch.vo
+backend/Selection.vo: backend/Selection.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Globalenvs.vo backend/Cminor.vo backend/Op.vo backend/CminorSel.vo
+backend/Selectionproof.vo: backend/Selectionproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Cminor.vo backend/Op.vo backend/CminorSel.vo backend/Selection.vo
backend/Registers.vo: backend/Registers.v lib/Coqlib.vo common/AST.vo lib/Maps.vo lib/Ordered.vo
-backend/RTL.vo: backend/RTL.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo
-backend/RTLgen.vo: backend/RTLgen.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo backend/Op.vo backend/Registers.vo backend/Cminor.vo backend/RTL.vo
-backend/RTLgenproof1.vo: backend/RTLgenproof1.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/Cminor.vo backend/RTL.vo backend/RTLgen.vo
-backend/RTLgenproof.vo: backend/RTLgenproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/Cminor.vo backend/RTL.vo backend/RTLgen.vo backend/RTLgenproof1.vo
-backend/RTLtyping.vo: backend/RTLtyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/Conventions.vo common/Globalenvs.vo common/Values.vo common/Mem.vo lib/Integers.vo common/Events.vo
-backend/Kildall.vo: backend/Kildall.v lib/Coqlib.vo lib/Iteration.vo lib/Maps.vo lib/Lattice.vo
+backend/RTL.vo: backend/RTL.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Registers.vo
+backend/RTLgen.vo: backend/RTLgen.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Switch.vo backend/Op.vo backend/Registers.vo backend/CminorSel.vo backend/RTL.vo
+backend/RTLgenspec.vo: backend/RTLgenspec.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo common/Switch.vo backend/Op.vo backend/Registers.vo backend/CminorSel.vo backend/RTL.vo backend/RTLgen.vo
+backend/RTLgenproof.vo: backend/RTLgenproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Smallstep.vo common/Globalenvs.vo common/Switch.vo backend/Registers.vo backend/Cminor.vo backend/Op.vo backend/CminorSel.vo backend/RTL.vo backend/RTLgen.vo backend/RTLgenspec.vo common/Errors.vo
+backend/RTLtyping.vo: backend/RTLtyping.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/Conventions.vo common/Globalenvs.vo common/Values.vo common/Mem.vo lib/Integers.vo common/Events.vo common/Smallstep.vo
+backend/Kildall.vo: backend/Kildall.v lib/Coqlib.vo lib/Iteration.vo lib/Maps.vo lib/Lattice.vo lib/Ordered.vo
backend/Constprop.vo: backend/Constprop.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/RTL.vo lib/Lattice.vo backend/Kildall.vo
-backend/Constpropproof.vo: backend/Constpropproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/RTL.vo lib/Lattice.vo backend/Kildall.vo backend/Constprop.vo
+backend/Constpropproof.vo: backend/Constpropproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Registers.vo backend/RTL.vo lib/Lattice.vo backend/Kildall.vo backend/Constprop.vo
backend/CSE.vo: backend/CSE.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/Kildall.vo
-backend/CSEproof.vo: backend/CSEproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/Kildall.vo backend/CSE.vo
+backend/CSEproof.vo: backend/CSEproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/Kildall.vo backend/CSE.vo
backend/Locations.vo: backend/Locations.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Values.vo
backend/Conventions.vo: backend/Conventions.v lib/Coqlib.vo common/AST.vo backend/Locations.vo
-backend/LTL.vo: backend/LTL.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo
+backend/LTL.vo: backend/LTL.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo
backend/LTLtyping.vo: backend/LTLtyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/RTL.vo backend/Locations.vo backend/LTL.vo backend/Conventions.vo
backend/InterfGraph.vo: backend/InterfGraph.v lib/Coqlib.vo lib/Maps.vo lib/Ordered.vo backend/Registers.vo backend/Locations.vo
backend/Coloring.vo: backend/Coloring.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/RTLtyping.vo backend/Locations.vo backend/Conventions.vo backend/InterfGraph.vo
backend/Coloringproof.vo: backend/Coloringproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/RTLtyping.vo backend/Locations.vo backend/Conventions.vo backend/InterfGraph.vo backend/Coloring.vo
-backend/Parallelmove.vo: backend/Parallelmove.v lib/Coqlib.vo lib/Parmov.vo common/Values.vo common/Events.vo common/AST.vo backend/Locations.vo backend/Conventions.vo
-backend/Allocation.vo: backend/Allocation.v lib/Coqlib.vo lib/Maps.vo lib/Lattice.vo common/AST.vo lib/Integers.vo common/Values.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/RTLtyping.vo backend/Kildall.vo backend/Locations.vo backend/Conventions.vo backend/Coloring.vo backend/Parallelmove.vo backend/LTL.vo
-backend/Allocproof.vo: backend/Allocproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/RTLtyping.vo backend/Locations.vo backend/Conventions.vo backend/Coloring.vo backend/Coloringproof.vo backend/Parallelmove.vo backend/Allocation.vo backend/LTL.vo
-backend/Alloctyping.vo: backend/Alloctyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/Locations.vo backend/LTL.vo backend/Coloring.vo backend/Coloringproof.vo backend/Allocation.vo backend/Allocproof.vo backend/RTLtyping.vo backend/LTLtyping.vo backend/Conventions.vo backend/Parallelmove.vo
+backend/Allocation.vo: backend/Allocation.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo lib/Lattice.vo common/AST.vo lib/Integers.vo common/Values.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/RTLtyping.vo backend/Kildall.vo backend/Locations.vo backend/Conventions.vo backend/Coloring.vo backend/LTL.vo
+backend/Allocproof.vo: backend/Allocproof.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Smallstep.vo common/Globalenvs.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/RTLtyping.vo backend/Locations.vo backend/Conventions.vo backend/Coloring.vo backend/Coloringproof.vo backend/Allocation.vo backend/LTL.vo
+backend/Alloctyping.vo: backend/Alloctyping.v lib/Coqlib.vo lib/Maps.vo common/Errors.vo common/AST.vo backend/Op.vo backend/Registers.vo backend/RTL.vo backend/Locations.vo backend/LTL.vo backend/Coloring.vo backend/Coloringproof.vo backend/Allocation.vo backend/Allocproof.vo backend/RTLtyping.vo backend/LTLtyping.vo backend/Conventions.vo
backend/Tunneling.vo: backend/Tunneling.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Values.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/LTL.vo
-backend/Tunnelingproof.vo: backend/Tunnelingproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/Tunneling.vo
-backend/Tunnelingtyping.vo: backend/Tunnelingtyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Values.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/LTLtyping.vo backend/Tunneling.vo
-backend/Linear.vo: backend/Linear.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/Conventions.vo
+backend/Tunnelingproof.vo: backend/Tunnelingproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/Tunneling.vo
+backend/Tunnelingtyping.vo: backend/Tunnelingtyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Values.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/LTLtyping.vo backend/Tunneling.vo backend/Tunnelingproof.vo
+backend/LTLin.vo: backend/LTLin.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/Conventions.vo
+backend/LTLintyping.vo: backend/LTLintyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/RTL.vo backend/Locations.vo backend/LTLin.vo backend/Conventions.vo
+backend/Linearize.vo: backend/Linearize.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Values.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/LTLin.vo backend/Kildall.vo lib/Lattice.vo
+backend/Linearizeproof.vo: backend/Linearizeproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/LTLtyping.vo backend/LTLin.vo backend/Linearize.vo lib/Lattice.vo
+backend/Linearizetyping.vo: backend/Linearizetyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/LTLtyping.vo backend/LTLin.vo backend/Linearize.vo backend/LTLintyping.vo backend/Conventions.vo
+backend/Linear.vo: backend/Linear.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/Conventions.vo
backend/Lineartyping.vo: backend/Lineartyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/RTL.vo backend/Locations.vo backend/Linear.vo backend/Conventions.vo
-backend/Linearize.vo: backend/Linearize.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Values.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/Linear.vo backend/Kildall.vo lib/Lattice.vo
-backend/Linearizeproof.vo: backend/Linearizeproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/Linear.vo backend/Linearize.vo lib/Lattice.vo
-backend/Linearizetyping.vo: backend/Linearizetyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/Locations.vo backend/LTL.vo backend/Linear.vo backend/Linearize.vo backend/LTLtyping.vo backend/Lineartyping.vo backend/Conventions.vo
-backend/Mach.vo: backend/Mach.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo
-backend/Machabstr.vo: backend/Machabstr.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Mem.vo lib/Integers.vo common/Values.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo backend/Mach.vo
+backend/Parallelmove.vo: backend/Parallelmove.v lib/Coqlib.vo lib/Parmov.vo common/Values.vo common/Events.vo common/AST.vo backend/Locations.vo backend/Conventions.vo
+backend/Reload.vo: backend/Reload.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/LTLin.vo backend/Conventions.vo backend/Parallelmove.vo backend/Linear.vo
+backend/Reloadproof.vo: backend/Reloadproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo backend/Allocproof.vo backend/LTLin.vo backend/LTLintyping.vo backend/Linear.vo backend/Parallelmove.vo backend/Reload.vo
+backend/Reloadtyping.vo: backend/Reloadtyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/Locations.vo backend/LTLin.vo backend/LTLintyping.vo backend/Linear.vo backend/Lineartyping.vo backend/Conventions.vo backend/Parallelmove.vo backend/Reload.vo backend/Reloadproof.vo
+backend/Mach.vo: backend/Mach.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo
+backend/Machabstr.vo: backend/Machabstr.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Mem.vo lib/Integers.vo common/Values.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo backend/Mach.vo
backend/Machtyping.vo: backend/Machtyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo common/Mem.vo lib/Integers.vo common/Values.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo backend/Mach.vo backend/Machabstr.vo
-backend/Stacking.vo: backend/Stacking.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo backend/Op.vo backend/RTL.vo backend/Locations.vo backend/Linear.vo backend/Lineartyping.vo backend/Mach.vo backend/Conventions.vo
-backend/Stackingproof.vo: backend/Stackingproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo backend/Op.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Locations.vo backend/Mach.vo backend/Machabstr.vo backend/Linear.vo backend/Lineartyping.vo backend/Conventions.vo backend/Stacking.vo
-backend/Stackingtyping.vo: backend/Stackingtyping.v lib/Coqlib.vo lib/Maps.vo lib/Integers.vo common/AST.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo backend/Linear.vo backend/Lineartyping.vo backend/Mach.vo backend/Machtyping.vo backend/Stacking.vo backend/Stackingproof.vo
-backend/Machabstr2mach.vo: backend/Machabstr2mach.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Machabstr.vo backend/Mach.vo backend/Machtyping.vo backend/Stackingproof.vo
-backend/PPC.vo: backend/PPC.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo
-backend/PPCgen.vo: backend/PPCgen.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Mach.vo backend/PPC.vo
-backend/PPCgenproof1.vo: backend/PPCgenproof1.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Mach.vo backend/Machtyping.vo backend/PPC.vo backend/PPCgen.vo backend/Conventions.vo
-backend/PPCgenproof.vo: backend/PPCgenproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Mach.vo backend/Machtyping.vo backend/PPC.vo backend/PPCgen.vo backend/PPCgenproof1.vo
-cfrontend/Csyntax.vo: cfrontend/Csyntax.v lib/Coqlib.vo lib/Integers.vo lib/Floats.vo common/AST.vo
-cfrontend/Csem.vo: cfrontend/Csem.v lib/Coqlib.vo lib/Maps.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/AST.vo common/Mem.vo common/Events.vo common/Globalenvs.vo cfrontend/Csyntax.vo
+backend/Bounds.vo: backend/Bounds.v lib/Coqlib.vo lib/Maps.vo common/AST.vo backend/Op.vo backend/Locations.vo backend/Linear.vo backend/Lineartyping.vo backend/Conventions.vo
+backend/Stacking.vo: backend/Stacking.v lib/Coqlib.vo lib/Maps.vo common/Errors.vo common/AST.vo lib/Integers.vo backend/Op.vo backend/RTL.vo backend/Locations.vo backend/Linear.vo backend/Bounds.vo backend/Mach.vo backend/Conventions.vo
+backend/Stackingproof.vo: backend/Stackingproof.v lib/Coqlib.vo lib/Maps.vo common/Errors.vo common/AST.vo lib/Integers.vo common/Values.vo backend/Op.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Locations.vo backend/Linear.vo backend/Lineartyping.vo backend/Mach.vo backend/Machabstr.vo backend/Bounds.vo backend/Conventions.vo backend/Stacking.vo
+backend/Stackingtyping.vo: backend/Stackingtyping.v lib/Coqlib.vo lib/Maps.vo common/Errors.vo lib/Integers.vo common/AST.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo backend/Linear.vo backend/Lineartyping.vo backend/Mach.vo backend/Machtyping.vo backend/Bounds.vo backend/Stacking.vo backend/Stackingproof.vo
+backend/Machconcr.vo: backend/Machconcr.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/Conventions.vo backend/Mach.vo backend/PPCgenretaddr.vo
+backend/Machabstr2concr.vo: backend/Machabstr2concr.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/Mach.vo backend/Machtyping.vo backend/Machabstr.vo backend/Machconcr.vo backend/Stackingproof.vo backend/PPCgenretaddr.vo
+backend/PPC.vo: backend/PPC.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo
+backend/PPCgen.vo: backend/PPCgen.v lib/Coqlib.vo lib/Maps.vo common/Errors.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Mach.vo backend/PPC.vo
+backend/PPCgenretaddr.vo: backend/PPCgenretaddr.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Mach.vo backend/PPC.vo backend/PPCgen.vo
+backend/PPCgenproof1.vo: backend/PPCgenproof1.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Globalenvs.vo backend/Op.vo backend/Locations.vo backend/Mach.vo backend/Machconcr.vo backend/Machtyping.vo backend/PPC.vo backend/PPCgen.vo backend/Conventions.vo
+backend/PPCgenproof.vo: backend/PPCgenproof.v lib/Coqlib.vo lib/Maps.vo common/Errors.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo common/Smallstep.vo backend/Op.vo backend/Locations.vo backend/Mach.vo backend/Machconcr.vo backend/Machtyping.vo backend/PPC.vo backend/PPCgen.vo backend/PPCgenretaddr.vo backend/PPCgenproof1.vo
+cfrontend/Csyntax.vo: cfrontend/Csyntax.v lib/Coqlib.vo common/Errors.vo lib/Integers.vo lib/Floats.vo common/AST.vo
+cfrontend/Csem.vo: cfrontend/Csem.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/AST.vo common/Mem.vo common/Events.vo common/Globalenvs.vo cfrontend/Csyntax.vo
cfrontend/Ctyping.vo: cfrontend/Ctyping.v lib/Coqlib.vo lib/Maps.vo common/AST.vo cfrontend/Csyntax.vo
-cfrontend/Cshmgen.vo: cfrontend/Cshmgen.v lib/Coqlib.vo lib/Integers.vo lib/Floats.vo common/AST.vo cfrontend/Csyntax.vo cfrontend/Csharpminor.vo
-cfrontend/Cshmgenproof1.vo: cfrontend/Cshmgenproof1.v lib/Coqlib.vo lib/Maps.vo lib/Integers.vo lib/Floats.vo common/AST.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo cfrontend/Csyntax.vo cfrontend/Csem.vo cfrontend/Ctyping.vo cfrontend/Csharpminor.vo cfrontend/Cshmgen.vo
-cfrontend/Cshmgenproof2.vo: cfrontend/Cshmgenproof2.v lib/Coqlib.vo lib/Maps.vo lib/Integers.vo lib/Floats.vo common/AST.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo cfrontend/Csyntax.vo cfrontend/Csem.vo cfrontend/Ctyping.vo cfrontend/Csharpminor.vo cfrontend/Cshmgen.vo cfrontend/Cshmgenproof1.vo
-cfrontend/Cshmgenproof3.vo: cfrontend/Cshmgenproof3.v lib/Coqlib.vo lib/Maps.vo lib/Integers.vo lib/Floats.vo common/AST.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo cfrontend/Csyntax.vo cfrontend/Csem.vo cfrontend/Ctyping.vo cfrontend/Csharpminor.vo cfrontend/Cshmgen.vo cfrontend/Cshmgenproof1.vo cfrontend/Cshmgenproof2.vo
-cfrontend/Csharpminor.vo: cfrontend/Csharpminor.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo
-cfrontend/Cminorgen.vo: cfrontend/Cminorgen.v lib/Coqlib.vo lib/Maps.vo lib/Ordered.vo common/AST.vo lib/Integers.vo common/Mem.vo cfrontend/Csharpminor.vo backend/Op.vo backend/Cminor.vo backend/Cmconstr.vo
-cfrontend/Cminorgenproof.vo: cfrontend/Cminorgenproof.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo cfrontend/Csharpminor.vo backend/Op.vo backend/Cminor.vo backend/Cmconstr.vo cfrontend/Cminorgen.vo backend/Cmconstrproof.vo
+cfrontend/Cshmgen.vo: cfrontend/Cshmgen.v lib/Coqlib.vo common/Errors.vo lib/Integers.vo lib/Floats.vo common/AST.vo cfrontend/Csyntax.vo backend/Cminor.vo cfrontend/Csharpminor.vo
+cfrontend/Cshmgenproof1.vo: cfrontend/Cshmgenproof1.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo lib/Integers.vo lib/Floats.vo common/AST.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo cfrontend/Csyntax.vo cfrontend/Csem.vo cfrontend/Ctyping.vo backend/Cminor.vo cfrontend/Csharpminor.vo cfrontend/Cshmgen.vo
+cfrontend/Cshmgenproof2.vo: cfrontend/Cshmgenproof2.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo lib/Integers.vo lib/Floats.vo common/AST.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo cfrontend/Csyntax.vo cfrontend/Csem.vo cfrontend/Ctyping.vo backend/Cminor.vo cfrontend/Csharpminor.vo cfrontend/Cshmgen.vo cfrontend/Cshmgenproof1.vo
+cfrontend/Cshmgenproof3.vo: cfrontend/Cshmgenproof3.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo lib/Integers.vo lib/Floats.vo common/AST.vo common/Values.vo common/Events.vo common/Mem.vo common/Globalenvs.vo cfrontend/Csyntax.vo cfrontend/Csem.vo cfrontend/Ctyping.vo backend/Cminor.vo cfrontend/Csharpminor.vo cfrontend/Cshmgen.vo cfrontend/Cshmgenproof1.vo cfrontend/Cshmgenproof2.vo
+cfrontend/Csharpminor.vo: cfrontend/Csharpminor.v lib/Coqlib.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo backend/Cminor.vo
+cfrontend/Cminorgen.vo: cfrontend/Cminorgen.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo lib/Ordered.vo common/AST.vo lib/Integers.vo common/Mem.vo cfrontend/Csharpminor.vo backend/Op.vo backend/Cminor.vo
+cfrontend/Cminorgenproof.vo: cfrontend/Cminorgenproof.v lib/Coqlib.vo common/Errors.vo lib/Maps.vo common/AST.vo lib/Integers.vo lib/Floats.vo common/Values.vo common/Mem.vo common/Events.vo common/Globalenvs.vo cfrontend/Csharpminor.vo backend/Cminor.vo cfrontend/Cminorgen.vo
diff --git a/Makefile b/Makefile
index 00b0000860ce5d20bc205033585f1957d10eaf10..bea28aca811e1386f63cf0e38f6538b40dfae244 100644
--- a/Makefile
+++ b/Makefile
@@ -12,30 +12,32 @@ LIB=Coqlib.v Maps.v Lattice.v Ordered.v \
# Files in common/
-COMMON=AST.v Events.v Globalenvs.v Mem.v Values.v Main.v
+COMMON=Errors.v AST.v Events.v Globalenvs.v Mem.v Values.v \
+ Smallstep.v Switch.v Main.v
# Files in backend/
BACKEND=\
- Op.v Cminor.v \
- Cmconstr.v Cmconstrproof.v \
+ Cminor.v Op.v CminorSel.v \
+ Selection.v Selectionproof.v \
Registers.v RTL.v \
- RTLgen.v RTLgenproof1.v RTLgenproof.v \
+ RTLgen.v RTLgenspec.v RTLgenproof.v \
RTLtyping.v \
Kildall.v \
Constprop.v Constpropproof.v \
CSE.v CSEproof.v \
Locations.v Conventions.v LTL.v LTLtyping.v \
InterfGraph.v Coloring.v Coloringproof.v \
- Parallelmove.v Allocation.v \
- Allocproof.v Alloctyping.v \
+ Allocation.v Allocproof.v Alloctyping.v \
Tunneling.v Tunnelingproof.v Tunnelingtyping.v \
- Linear.v Lineartyping.v \
+ LTLin.v LTLintyping.v \
Linearize.v Linearizeproof.v Linearizetyping.v \
+ Linear.v Lineartyping.v \
+ Parallelmove.v Reload.v Reloadproof.v Reloadtyping.v \
Mach.v Machabstr.v Machtyping.v \
- Stacking.v Stackingproof.v Stackingtyping.v \
- Machabstr2mach.v \
- PPC.v PPCgen.v PPCgenproof1.v PPCgenproof.v
+ Bounds.v Stacking.v Stackingproof.v Stackingtyping.v \
+ Machconcr.v Machabstr2concr.v \
+ PPC.v PPCgen.v PPCgenretaddr.v PPCgenproof1.v PPCgenproof.v
# Files in cfrontend/
@@ -47,7 +49,7 @@ CFRONTEND=Csyntax.v Csem.v Ctyping.v Cshmgen.v \
FILES=$(LIB:%=lib/%) $(COMMON:%=common/%) $(BACKEND:%=backend/%) $(CFRONTEND:%=cfrontend/%)
-FLATFILES=$(LIB) $(BACKEND) $(CFRONTEND)
+FLATFILES=$(LIB) $(COMMON) $(BACKEND) $(CFRONTEND)
proof: $(FILES:.v=.vo)
@@ -65,24 +67,30 @@ cil:
$(MAKE) -C cil
documentation:
- $(COQDOC) --html -d doc $(FLATFILES:%.v=--glob-from doc/%.glob) $(FILES)
- doc/removeproofs doc/lib.*.html doc/backend.*.html
+ @ln -f $(FILES) doc/
+ @mkdir -p doc/html
+ cd doc; $(COQDOC) --html -d html \
+ $(FLATFILES:%.v=--glob-from %.glob) $(FLATFILES)
+ @cd doc; rm -f $(FLATFILES)
+ cp doc/coqdoc.css doc/html/coqdoc.css
+ doc/removeproofs doc/html/*.html
latexdoc:
- $(COQDOC) --latex -o doc/doc.tex -g $(FILES)
+ cd doc; $(COQDOC) --latex -o doc/doc.tex -g $(FILES)
.SUFFIXES: .v .vo
.v.vo:
@rm -f doc/glob/$(*F).glob
- $(COQC) -dump-glob doc/$(*F).glob $*.v
+ @echo "COQC $*.v"
+ @$(COQC) -dump-glob doc/$(*F).glob $*.v
depend:
$(COQDEP) $(FILES) > .depend
clean:
rm -f */*.vo *~ */*~
- rm -f doc/lib.*.html doc/backend.*.html doc/*.glob
+ rm -rf doc/html doc/*.glob
$(MAKE) -C extraction clean
$(MAKE) -C test/cminor clean
diff --git a/backend/Allocation.v b/backend/Allocation.v
index 74c85cfe5fc0c943486992183fe33de74a188e63..eab5233da19aa6154a94dcbf13bfc31b537003e8 100644
--- a/backend/Allocation.v
+++ b/backend/Allocation.v
@@ -1,7 +1,7 @@
-(** Register allocation, spilling, reloading and explicitation of
- calling conventions. *)
+(** Register allocation. *)
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import Lattice.
Require Import AST.
@@ -16,15 +16,14 @@ Require Import Kildall.
Require Import Locations.
Require Import Conventions.
Require Import Coloring.
-Require Import Parallelmove.
(** * Liveness analysis over RTL *)
(** A register [r] is live at a point [p] if there exists a path
- from [p] to some instruction that uses [r] as argument,
- and [r] is not redefined along this path.
- Liveness can be computed by a backward dataflow analysis.
- The analysis operates over sets of (live) pseudo-registers. *)
+ from [p] to some instruction that uses [r] as argument,
+ and [r] is not redefined along this path.
+ Liveness can be computed by a backward dataflow analysis.
+ The analysis operates over sets of (live) pseudo-registers. *)
Notation reg_live := Regset.add.
Notation reg_dead := Regset.remove.
@@ -50,25 +49,25 @@ Fixpoint reg_list_dead
end.
(** Here is the transfer function for the dataflow analysis.
- Since this is a backward dataflow analysis, it takes as argument
- the abstract register set ``after'' the given instruction,
- i.e. the registers that are live after; and it returns as result
- the abstract register set ``before'' the given instruction,
- i.e. the registers that must be live before.
- The general relation between ``live before'' and ``live after''
- an instruction is that a register is live before if either
- it is one of the arguments of the instruction, or it is not the result
- of the instruction and it is live after.
- However, if the result of a side-effect-free instruction is not
- live ``after'', the whole instruction will be removed later
- (since it computes a useless result), thus its arguments need not
- be live ``before''. *)
+ Since this is a backward dataflow analysis, it takes as argument
+ the abstract register set ``after'' the given instruction,
+ i.e. the registers that are live after; and it returns as result
+ the abstract register set ``before'' the given instruction,
+ i.e. the registers that must be live before.
+ The general relation between ``live before'' and ``live after''
+ an instruction is that a register is live before if either
+ it is one of the arguments of the instruction, or it is not the result
+ of the instruction and it is live after.
+ However, if the result of a side-effect-free instruction is not
+ live ``after'', the whole instruction will be removed later
+ (since it computes a useless result), thus its arguments need not
+ be live ``before''. *)
Definition transfer
(f: RTL.function) (pc: node) (after: Regset.t) : Regset.t :=
match f.(fn_code)!pc with
| None =>
- after
+ Regset.empty
| Some i =>
match i with
| Inop s =>
@@ -88,18 +87,20 @@ Definition transfer
| Icall sig ros args res s =>
reg_list_live args
(reg_sum_live ros (reg_dead res after))
+ | Itailcall sig ros args =>
+ reg_list_live args (reg_sum_live ros Regset.empty)
| Ialloc arg res s =>
reg_live arg (reg_dead res after)
| Icond cond args ifso ifnot =>
reg_list_live args after
| Ireturn optarg =>
- reg_option_live optarg after
+ reg_option_live optarg Regset.empty
end
end.
(** The liveness analysis is then obtained by instantiating the
- general framework for backward dataflow analysis provided by
- module [Kildall]. *)
+ general framework for backward dataflow analysis provided by
+ module [Kildall]. *)
Module RegsetLat := LFSet(Regset).
Module DS := Backward_Dataflow_Solver(RegsetLat)(NodeSetBackward).
@@ -107,315 +108,108 @@ Module DS := Backward_Dataflow_Solver(RegsetLat)(NodeSetBackward).
Definition analyze (f: RTL.function): option (PMap.t Regset.t) :=
DS.fixpoint (successors f) f.(fn_nextpc) (transfer f) nil.
-(** * Spilling and reloading *)
-
-(** LTL operations, like those of the target processor, operate only
- over machine registers, but not over stack slots. Consider
- the RTL instruction
-<<
- r1 <- Iop(Oadd, r1 :: r2 :: nil)
->>
- and assume that [r1] and [r2] are assigned to stack locations [S s1]
- and [S s2], respectively. The translated LTL code must load these
- stack locations into temporary integer registers (this is called
- ``reloading''), perform the [Oadd] operation over these temporaries,
- leave the result in a temporary, then store the temporary back to
- stack location [S s1] (this is called ``spilling''). In other term,
- the generated LTL code has the following shape:
-<<
- IT1 <- Bgetstack s1;
- IT2 <- Bgetstack s2;
- IT1 <- Bop(Oadd, IT1 :: IT2 :: nil);
- Bsetstack s1 IT1;
->>
- This section provides functions that assist in choosing appropriate
- temporaries and inserting the required spilling and reloading
- operations. *)
-
-(** ** Allocation of temporary registers for reloading and spilling. *)
-
-(** [reg_for l] returns a machine register appropriate for working
- over the location [l]: either the machine register [m] if [l = R m],
- or a temporary register of [l]'s type if [l] is a stack slot. *)
-
-Definition reg_for (l: loc) : mreg :=
- match l with
- | R r => r
- | S s => match slot_type s with Tint => IT1 | Tfloat => FT1 end
- end.
-
-(** [regs_for ll] is similar, for a list of locations [ll] of length
- at most 3. We ensure that distinct temporaries are used for
- different elements of [ll]. *)
-
-Fixpoint regs_for_rec (locs: list loc) (itmps ftmps: list mreg)
- {struct locs} : list mreg :=
- match locs, itmps, ftmps with
- | l1 :: ls, it1 :: its, ft1 :: fts =>
- match l1 with
- | R r => r
- | S s => match slot_type s with Tint => it1 | Tfloat => ft1 end
- end
- :: regs_for_rec ls its fts
- | _, _, _ => nil
- end.
-
-Definition regs_for (locs: list loc) :=
- regs_for_rec locs (IT1 :: IT2 :: IT3 :: nil) (FT1 :: FT2 :: FT3 :: nil).
-
-(** ** Insertion of LTL reloads, stores and moves *)
+(** * Translation from RTL to LTL *)
Require Import LTL.
-(** [add_spill src dst k] prepends to [k] the instructions needed
- to assign location [dst] the value of machine register [mreg]. *)
-
-Definition add_spill (src: mreg) (dst: loc) (k: block) :=
- match dst with
- | R rd => if mreg_eq src rd then k else Bop Omove (src :: nil) rd k
- | S sl => Bsetstack src sl k
- end.
-
-(** [add_reload src dst k] prepends to [k] the instructions needed
- to assign machine register [mreg] the value of the location [src]. *)
-
-Definition add_reload (src: loc) (dst: mreg) (k: block) :=
- match src with
- | R rs => if mreg_eq rs dst then k else Bop Omove (rs :: nil) dst k
- | S sl => Bgetstack sl dst k
- end.
-
-(** [add_reloads] is similar for a list of locations (as sources)
- and a list of machine registers (as destinations). *)
-
-Fixpoint add_reloads (srcs: list loc) (dsts: list mreg) (k: block)
- {struct srcs} : block :=
- match srcs, dsts with
- | s1 :: sl, t1 :: tl =>
- add_reload s1 t1 (add_reloads sl tl k)
- | _, _ =>
- k
- end.
-
-(** [add_move src dst k] prepends to [k] the instructions that copy
- the value of location [src] into location [dst]. *)
-
-Definition add_move (src dst: loc) (k: block) :=
- if Loc.eq src dst then k else
- match src, dst with
- | R rs, _ =>
- add_spill rs dst k
- | _, R rd =>
- add_reload src rd k
- | S ss, S sd =>
- let tmp :=
- match slot_type ss with Tint => IT1 | Tfloat => FT1 end in
- add_reload src tmp (add_spill tmp dst k)
- end.
-
-(** [parallel_move srcs dsts k] is similar, but for a list of
- source locations and a list of destination locations of the same
- length. This is a parallel move, meaning that arbitrary overlap
- between the sources and destinations is permitted. *)
-
-Definition parallel_move (srcs dsts: list loc) (k: block) : block :=
- List.fold_right
- (fun p k => add_move (fst p) (snd p) k)
- k (parmove srcs dsts).
-
-(** ** Constructors for LTL instructions *)
-
-(** The following functions generate LTL instructions operating
- over the given locations. Appropriate reloading and spilling operations
- are added around the core LTL instruction. *)
-
-Definition add_op (op: operation) (args: list loc) (res: loc) (s: node) :=
- match is_move_operation op args with
- | Some src =>
- add_move src res (Bgoto s)
- | None =>
- let rargs := regs_for args in
- let rres := reg_for res in
- add_reloads args rargs (Bop op rargs rres (add_spill rres res (Bgoto s)))
- end.
-
-Definition add_load (chunk: memory_chunk) (addr: addressing)
- (args: list loc) (dst: loc) (s: node) :=
- let rargs := regs_for args in
- let rdst := reg_for dst in
- add_reloads args rargs
- (Bload chunk addr rargs rdst (add_spill rdst dst (Bgoto s))).
-
-Definition add_store (chunk: memory_chunk) (addr: addressing)
- (args: list loc) (src: loc) (s: node) :=
- match regs_for (src :: args) with
- | nil => Breturn (* never happens *)
- | rsrc :: rargs =>
- add_reloads (src :: args) (rsrc :: rargs)
- (Bstore chunk addr rargs rsrc (Bgoto s))
- end.
-
-Definition add_alloc (arg: loc) (res: loc) (s: node) :=
- add_reload arg Conventions.loc_alloc_argument
- (Balloc (add_spill Conventions.loc_alloc_result res (Bgoto s))).
-
-(** For function calls, we also add appropriate moves to and from
- the canonical locations for function arguments and function results,
- as dictated by the calling conventions. *)
-
-Definition add_call (sig: signature) (ros: loc + ident)
- (args: list loc) (res: loc) (s: node) :=
- let rargs := loc_arguments sig in
- let rres := loc_result sig in
- match ros with
- | inl fn =>
- (add_reload fn IT3
- (parallel_move args rargs
- (Bcall sig (inl _ IT3) (add_spill rres res (Bgoto s)))))
- | inr id =>
- parallel_move args rargs
- (Bcall sig (inr _ id) (add_spill rres res (Bgoto s)))
- end.
-
-Definition add_cond (cond: condition) (args: list loc) (ifso ifnot: node) :=
- let rargs := regs_for args in
- add_reloads args rargs (Bcond cond rargs ifso ifnot).
-
-(** For function returns, we add the appropriate move of the result
- to the conventional location for the function result. If the function
- returns with no value, we explicitly set the function result register
- to the [Vundef] value, for consistency with RTL's semantics. *)
-
-Definition add_return (sig: signature) (optarg: option loc) :=
- match optarg with
- | Some arg => add_reload arg (loc_result sig) Breturn
- | None => Bop Oundef nil (loc_result sig) Breturn
- end.
-
-(** For function entry points, we move from the parameter locations
- dictated by the calling convention to the locations of the function
- parameters. We also explicitly set to [Vundef] the locations
- of pseudo-registers that are live at function entry but are not
- parameters, again for consistency with RTL's semantics. *)
-
-Fixpoint add_undefs (ll: list loc) (b: block) {struct ll} : block :=
- match ll with
- | nil => b
- | R r :: ls => Bop Oundef nil r (add_undefs ls b)
- | S s :: ls => add_undefs ls b
- end.
-
-Definition add_entry (sig: signature) (params: list loc) (undefs: list loc)
- (s: node) :=
- parallel_move (loc_parameters sig) params (add_undefs undefs (Bgoto s)).
-
-(** * Translation from RTL to LTL *)
-
-(** Each [RTL] instruction translates to an [LTL] basic block.
+(** Each [RTL] instruction translates to an [LTL] instruction.
The register assignment [assign] returned by register allocation
is applied to the arguments and results of the RTL
- instruction, followed by an invocation of the appropriate [LTL]
- constructor function that will deal with spilling, reloading and
- calling conventions. In addition, dead instructions are eliminated.
+ instruction. Moreover, dead instructions and redundant moves
+ are eliminated (turned into a [Lnop] instruction).
Dead instructions are instructions without side-effects ([Iop] and
[Iload]) whose result register is dead, i.e. whose result value
- is never used. *)
+ is never used. Redundant moves are moves whose source and destination
+ are assigned the same location. *)
+
+Definition is_redundant_move
+ (op: operation) (args: list reg) (res: reg) (assign: reg -> loc) : bool :=
+ match is_move_operation op args with
+ | None => false
+ | Some src => if Loc.eq (assign src) (assign res) then true else false
+ end.
Definition transf_instr
(f: RTL.function) (live: PMap.t Regset.t) (assign: reg -> loc)
- (pc: node) (instr: RTL.instruction) : LTL.block :=
+ (pc: node) (instr: RTL.instruction) : LTL.instruction :=
match instr with
| Inop s =>
- Bgoto s
+ Lnop s
| Iop op args res s =>
if Regset.mem res live!!pc then
- add_op op (List.map assign args) (assign res) s
+ if is_redundant_move op args res assign then
+ Lnop s
+ else
+ Lop op (List.map assign args) (assign res) s
else
- Bgoto s
+ Lnop s
| Iload chunk addr args dst s =>
if Regset.mem dst live!!pc then
- add_load chunk addr (List.map assign args) (assign dst) s
+ Lload chunk addr (List.map assign args) (assign dst) s
else
- Bgoto s
+ Lnop s
| Istore chunk addr args src s =>
- add_store chunk addr (List.map assign args) (assign src) s
+ Lstore chunk addr (List.map assign args) (assign src) s
| Icall sig ros args res s =>
- add_call sig (sum_left_map assign ros) (List.map assign args)
- (assign res) s
+ Lcall sig (sum_left_map assign ros) (List.map assign args)
+ (assign res) s
+ | Itailcall sig ros args =>
+ Ltailcall sig (sum_left_map assign ros) (List.map assign args)
| Ialloc arg res s =>
- add_alloc (assign arg) (assign res) s
+ Lalloc (assign arg) (assign res) s
| Icond cond args ifso ifnot =>
- add_cond cond (List.map assign args) ifso ifnot
+ Lcond cond (List.map assign args) ifso ifnot
| Ireturn optarg =>
- add_return f.(RTL.fn_sig) (option_map assign optarg)
+ Lreturn (option_map assign optarg)
end.
-Definition transf_entrypoint
- (f: RTL.function) (live: PMap.t Regset.t) (assign: reg -> loc)
- (newcode: LTL.code) : LTL.code :=
- let oldentry := RTL.fn_entrypoint f in
- let newentry := RTL.fn_nextpc f in
- let undefs :=
- Regset.elements (reg_list_dead (RTL.fn_params f)
- (transfer f oldentry live!!oldentry)) in
- PTree.set
- newentry
- (add_entry (RTL.fn_sig f)
- (List.map assign (RTL.fn_params f))
- (List.map assign undefs)
- oldentry)
- newcode.
-
-Lemma transf_entrypoint_wf:
+Lemma transf_body_wf:
forall (f: RTL.function) (live: PMap.t Regset.t) (assign: reg -> loc),
- let tc1 := PTree.map (transf_instr f live assign) (RTL.fn_code f) in
- let tc2 := transf_entrypoint f live assign tc1 in
- forall (pc: node), Plt pc (Psucc (RTL.fn_nextpc f)) \/ tc2!pc = None.
+ let tc := PTree.map (transf_instr f live assign) (RTL.fn_code f) in
+ forall (pc: node), Plt pc (RTL.fn_nextpc f) \/ tc!pc = None.
Proof.
- intros. case (plt pc (Psucc (RTL.fn_nextpc f))); intro.
- left. auto.
- right.
- assert (pc <> RTL.fn_nextpc f).
- red; intro. subst pc. elim n. apply Plt_succ.
- assert (~ (Plt pc (RTL.fn_nextpc f))).
- red; intro. elim n. apply Plt_trans_succ; auto.
- unfold tc2. unfold transf_entrypoint.
- rewrite PTree.gso; auto.
- unfold tc1. rewrite PTree.gmap.
- elim (RTL.fn_code_wf f pc); intro.
- contradiction. unfold option_map. rewrite H1. auto.
+ intros. elim (RTL.fn_code_wf f pc); intro.
+ left. auto. right. unfold tc. rewrite PTree.gmap.
+ unfold option_map. rewrite H. auto.
Qed.
+Definition transf_fun (f: RTL.function) (live: PMap.t Regset.t)
+ (assign: reg -> loc) : LTL.function :=
+ LTL.mkfunction
+ (RTL.fn_sig f)
+ (List.map assign (RTL.fn_params f))
+ (RTL.fn_stacksize f)
+ (PTree.map (transf_instr f live assign) (RTL.fn_code f))
+ (RTL.fn_entrypoint f)
+ (RTL.fn_nextpc f)
+ (transf_body_wf f live assign).
+
(** The translation of a function performs liveness analysis,
construction and coloring of the inference graph, and per-instruction
transformation as described above. *)
-Definition transf_function (f: RTL.function) : option LTL.function :=
+Definition live0 (f: RTL.function) (live: PMap.t Regset.t) :=
+ transfer f f.(RTL.fn_entrypoint) live!!(f.(RTL.fn_entrypoint)).
+
+Open Scope string_scope.
+
+Definition transf_function (f: RTL.function) : res LTL.function :=
match type_function f with
- | None => None
- | Some env =>
+ | Error msg => Error msg
+ | OK env =>
match analyze f with
- | None => None
+ | None => Error (msg "Liveness analysis failure")
| Some live =>
- let pc0 := f.(RTL.fn_entrypoint) in
- let live0 := transfer f pc0 live!!pc0 in
- match regalloc f live live0 env with
- | None => None
- | Some assign =>
- Some (LTL.mkfunction
- (RTL.fn_sig f)
- (RTL.fn_stacksize f)
- (transf_entrypoint f live assign
- (PTree.map (transf_instr f live assign) (RTL.fn_code f)))
- (RTL.fn_nextpc f)
- (transf_entrypoint_wf f live assign))
- end
+ match regalloc f live (live0 f live) env with
+ | None => Error (msg "Incorrect graph coloring")
+ | Some assign => OK (transf_fun f live assign)
+ end
end
end.
-Definition transf_fundef (fd: RTL.fundef) : option LTL.fundef :=
- transf_partial_fundef transf_function fd.
+Definition transf_fundef (fd: RTL.fundef) : res LTL.fundef :=
+ AST.transf_partial_fundef transf_function fd.
-Definition transf_program (p: RTL.program) : option LTL.program :=
+Definition transf_program (p: RTL.program) : res LTL.program :=
transform_partial_program transf_fundef p.
diff --git a/backend/Allocproof.v b/backend/Allocproof.v
index f0b2968f4a968870c8cef5a6faafe07833d3306d..1b5a41563055e6168c02b39cf3826d2daa7e9b1a 100644
--- a/backend/Allocproof.v
+++ b/backend/Allocproof.v
@@ -1,16 +1,17 @@
(** Correctness proof for the [Allocation] pass (translation from
RTL to LTL). *)
-Require Import Relations.
Require Import FSets.
Require Import SetoidList.
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import AST.
Require Import Integers.
Require Import Values.
Require Import Mem.
Require Import Events.
+Require Import Smallstep.
Require Import Globalenvs.
Require Import Op.
Require Import Registers.
@@ -20,7 +21,6 @@ Require Import Locations.
Require Import Conventions.
Require Import Coloring.
Require Import Coloringproof.
-Require Import Parallelmove.
Require Import Allocation.
(** * Semantic properties of calling conventions *)
@@ -53,9 +53,27 @@ Proof.
auto.
case (In_dec Loc.eq (R (loc_result sig)) destroyed_at_call); intro.
auto.
- elim n0. apply loc_result_acceptable.
+ elim n0. apply loc_result_caller_save.
Qed.
+(** Function arguments for a tail call are preserved by a
+ [return_regs] operation. *)
+
+Lemma return_regs_arguments:
+ forall sig caller callee,
+ tailcall_possible sig ->
+ map (LTL.return_regs caller callee) (loc_arguments sig) =
+ map callee (loc_arguments sig).
+Proof.
+ intros. apply list_map_exten; intros.
+ generalize (H x H0). destruct x; intro.
+ unfold LTL.return_regs.
+ destruct (In_dec Loc.eq (R m) temporaries). auto.
+ destruct (In_dec Loc.eq (R m) destroyed_at_call). auto.
+ elim n0. eapply arguments_caller_save; eauto.
+ contradiction.
+Qed.
+
(** Acceptable locations that are not destroyed at call keep
their values across a call. *)
@@ -73,31 +91,22 @@ Proof.
auto.
Qed.
-(** * Correctness condition for the liveness analysis *)
-
-(** The liveness information computed by the dataflow analysis is
- correct in the following sense: all registers live ``before''
- an instruction are live ``after'' all of its predecessors. *)
+(** Characterization of parallel assignments. *)
-Lemma analyze_correct:
- forall (f: function) (live: PMap.t Regset.t) (n s: node),
- analyze f = Some live ->
- f.(fn_code)!n <> None ->
- f.(fn_code)!s <> None ->
- In s (successors f n) ->
- RegsetLat.ge live!!n (transfer f s live!!s).
+Lemma parmov_spec:
+ forall ls srcs dsts,
+ Loc.norepet dsts -> List.length srcs = List.length dsts ->
+ List.map (LTL.parmov srcs dsts ls) dsts = List.map ls srcs /\
+ (forall l, Loc.notin l dsts -> LTL.parmov srcs dsts ls l = ls l).
Proof.
- intros.
- eapply DS.fixpoint_solution.
- unfold analyze in H. eexact H.
- elim (fn_code_wf f n); intro. auto. contradiction.
- elim (fn_code_wf f s); intro. auto. contradiction.
+ induction srcs; destruct dsts; simpl; intros; try discriminate.
auto.
+ inv H. inv H0. destruct (IHsrcs _ H4 H1). split.
+ f_equal. apply Locmap.gss. rewrite <- H. apply list_map_exten; intros.
+ symmetry. apply Locmap.gso. eapply Loc.in_notin_diff; eauto.
+ intros x [A B]. rewrite Locmap.gso; auto. apply Loc.diff_sym; auto.
Qed.
-Definition live0 (f: RTL.function) (live: PMap.t Regset.t) :=
- transfer f f.(RTL.fn_entrypoint) live!!(f.(RTL.fn_entrypoint)).
-
(** * Properties of allocated locations *)
(** We list here various properties of the locations [alloc r],
@@ -112,19 +121,6 @@ Variable live: PMap.t Regset.t.
Variable alloc: reg -> loc.
Hypothesis ALLOC: regalloc f live (live0 f live) env = Some alloc.
-Lemma loc_acceptable_noteq_diff:
- forall l1 l2,
- loc_acceptable l1 -> l1 <> l2 -> Loc.diff l1 l2.
-Proof.
- unfold loc_acceptable, Loc.diff; destruct l1; destruct l2;
- try (destruct s); try (destruct s0); intros; auto; try congruence.
- case (zeq z z0); intro.
- compare t t0; intro.
- subst z0; subst t0; tauto.
- tauto. tauto.
- contradiction. contradiction.
-Qed.
-
Lemma regalloc_noteq_diff:
forall r1 l2,
alloc r1 <> l2 -> Loc.diff (alloc r1) l2.
@@ -134,18 +130,6 @@ Proof.
auto.
Qed.
-Lemma loc_acceptable_notin_notin:
- forall r ll,
- loc_acceptable r ->
- ~(In r ll) -> Loc.notin r ll.
-Proof.
- induction ll; simpl; intros.
- auto.
- split. apply loc_acceptable_noteq_diff. assumption.
- apply sym_not_equal. tauto.
- apply IHll. assumption. tauto.
-Qed.
-
Lemma regalloc_notin_notin:
forall r ll,
~(In (alloc r) ll) -> Loc.notin (alloc r) ll.
@@ -153,6 +137,15 @@ Proof.
intros. apply loc_acceptable_notin_notin.
eapply regalloc_acceptable; eauto. auto.
Qed.
+
+Lemma regalloc_notin_notin_2:
+ forall l rl,
+ ~(In l (map alloc rl)) -> Loc.notin l (map alloc rl).
+Proof.
+ induction rl; simpl; intros. auto.
+ split. apply Loc.diff_sym. apply regalloc_noteq_diff. tauto.
+ apply IHrl. tauto.
+Qed.
Lemma regalloc_norepet_norepet:
forall rl,
@@ -215,7 +208,7 @@ Hypothesis REGALLOC: regalloc f flive (live0 f flive) env = Some assign.
of [assign r] can be arbitrary. *)
Definition agree (live: Regset.t) (rs: regset) (ls: locset) : Prop :=
- forall (r: reg), Regset.In r live -> ls (assign r) = rs#r.
+ forall (r: reg), Regset.In r live -> Val.lessdef (rs#r) (ls (assign r)).
(** What follows is a long list of lemmas expressing properties
of the [agree_live_regs] predicate that are useful for the
@@ -232,6 +225,24 @@ Proof.
apply H0. apply H. auto.
Qed.
+Lemma agree_succ:
+ forall n s rs ls live,
+ analyze f = Some live ->
+ In s (RTL.successors f n) ->
+ agree live!!n rs ls ->
+ agree (transfer f s live!!s) rs ls.
+Proof.
+ intros.
+ elim (RTL.fn_code_wf f n); intro.
+ elim (RTL.fn_code_wf f s); intro.
+ apply agree_increasing with (live!!n).
+ eapply DS.fixpoint_solution. unfold analyze in H; eauto.
+ auto. auto. auto. auto.
+ unfold transfer. rewrite H3.
+ red; intros. elim (Regset.empty_1 _ H4).
+ unfold RTL.successors in H0; rewrite H2 in H0; elim H0.
+Qed.
+
(** Some useful special cases of [agree_increasing]. *)
@@ -266,7 +277,7 @@ Qed.
Lemma agree_eval_reg:
forall r live rs ls,
- agree (reg_live r live) rs ls -> ls (assign r) = rs#r.
+ agree (reg_live r live) rs ls -> Val.lessdef (rs#r) (ls (assign r)).
Proof.
intros. apply H. apply Regset.add_1. auto.
Qed.
@@ -276,11 +287,11 @@ Qed.
Lemma agree_eval_regs:
forall rl live rs ls,
agree (reg_list_live rl live) rs ls ->
- List.map ls (List.map assign rl) = rs##rl.
+ Val.lessdef_list (rs##rl) (List.map ls (List.map assign rl)).
Proof.
induction rl; simpl; intros.
- reflexivity.
- apply (f_equal2 (@cons val)).
+ constructor.
+ constructor.
apply agree_eval_reg with live.
apply agree_reg_list_live with rl. auto.
eapply IHrl. eexact H.
@@ -322,21 +333,18 @@ Qed.
are mapped to locations other than that of [r]. *)
Lemma agree_assign_live:
- forall live r rs ls ls' v,
+ forall live r rs ls v v',
(forall s,
Regset.In s live -> s <> r -> assign s <> assign r) ->
- ls' (assign r) = v ->
- (forall l, Loc.diff l (assign r) -> Loc.notin l temporaries -> ls' l = ls l) ->
+ Val.lessdef v v' ->
agree (reg_dead r live) rs ls ->
- agree live (rs#r <- v) ls'.
+ agree live (rs#r <- v) (Locmap.set (assign r) v' ls).
Proof.
- unfold agree; intros.
- case (Reg.eq r r0); intro.
- subst r0. rewrite Regmap.gss. assumption.
- rewrite Regmap.gso; auto.
- rewrite H1. apply H2. apply Regset.remove_2; auto.
- eapply regalloc_noteq_diff. eauto. apply H. auto. auto.
- eapply regalloc_not_temporary; eauto.
+ unfold agree; intros. rewrite Regmap.gsspec.
+ destruct (peq r0 r).
+ subst r0. rewrite Locmap.gss. auto.
+ rewrite Locmap.gso. apply H1. apply Regset.remove_2; auto.
+ eapply regalloc_noteq_diff. eauto. apply sym_not_equal. apply H. auto. auto.
Qed.
(** This is a special case of the previous lemma where the value [v]
@@ -347,30 +355,47 @@ Qed.
are mapped to locations other than that of [res]. *)
Lemma agree_move_live:
- forall live arg res rs (ls ls': locset),
+ forall live arg res rs (ls: locset),
(forall r,
Regset.In r live -> r <> res -> r <> arg ->
assign r <> assign res) ->
- ls' (assign res) = ls (assign arg) ->
- (forall l, Loc.diff l (assign res) -> Loc.notin l temporaries -> ls' l = ls l) ->
agree (reg_live arg (reg_dead res live)) rs ls ->
- agree live (rs#res <- (rs#arg)) ls'.
+ agree live (rs#res <- (rs#arg)) (Locmap.set (assign res) (ls (assign arg)) ls).
Proof.
- unfold agree; intros.
- case (Reg.eq res r); intro.
- subst r. rewrite Regmap.gss. rewrite H0. apply H2.
+ unfold agree; intros. rewrite Regmap.gsspec. destruct (peq r res).
+ subst r. rewrite Locmap.gss. apply H0.
apply Regset.add_1; auto.
- rewrite Regmap.gso; auto.
- case (Loc.eq (assign r) (assign res)); intro.
- rewrite e. rewrite H0.
- case (Reg.eq arg r); intro.
- subst r. apply H2. apply Regset.add_1; auto.
- elim (H r); auto.
- rewrite H1. apply H2.
- case (Reg.eq arg r); intro. subst r. apply Regset.add_1; auto.
- apply Regset.add_2. apply Regset.remove_2. auto. auto.
- eapply regalloc_noteq_diff; eauto.
- eapply regalloc_not_temporary; eauto.
+ destruct (Reg.eq r arg).
+ subst r.
+ replace (Locmap.set (assign res) (ls (assign arg)) ls (assign arg))
+ with (ls (assign arg)).
+ apply H0. apply Regset.add_1. auto.
+ symmetry. destruct (Loc.eq (assign arg) (assign res)).
+ rewrite <- e. apply Locmap.gss.
+ apply Locmap.gso. eapply regalloc_noteq_diff; eauto.
+
+ rewrite Locmap.gso. apply H0. apply Regset.add_2. apply Regset.remove_2. auto. auto.
+ eapply regalloc_noteq_diff; eauto. apply sym_not_equal. apply H; auto.
+Qed.
+
+(** Yet another special case corresponding to the case of
+ a redundant move. *)
+
+Lemma agree_redundant_move_live:
+ forall live arg res rs (ls: locset),
+ (forall r,
+ Regset.In r live -> r <> res -> r <> arg ->
+ assign r <> assign res) ->
+ agree (reg_live arg (reg_dead res live)) rs ls ->
+ assign res = assign arg ->
+ agree live (rs#res <- (rs#arg)) ls.
+Proof.
+ intros.
+ apply agree_exten with (Locmap.set (assign res) (ls (assign arg)) ls).
+ eapply agree_move_live; eauto.
+ intros. symmetry. rewrite H1. destruct (Loc.eq l (assign arg)).
+ subst l. apply Locmap.gss.
+ apply Locmap.gso. eapply regalloc_noteq_diff; eauto.
Qed.
(** This complicated lemma states agreement between the states after
@@ -384,7 +409,7 @@ Lemma agree_call:
~(In (assign r) Conventions.destroyed_at_call)) ->
(forall r,
Regset.In r live -> r <> res -> assign r <> assign res) ->
- ls' (assign res) = v ->
+ Val.lessdef v (ls' (assign res)) ->
(forall l,
Loc.notin l destroyed_at_call -> loc_acceptable l -> Loc.diff l (assign res) ->
ls' l = ls l) ->
@@ -413,757 +438,33 @@ Lemma agree_init_regs:
(forall r1 r2,
In r1 rl -> Regset.In r2 live -> r1 <> r2 ->
assign r1 <> assign r2) ->
- List.map ls (List.map assign rl) = vl ->
- agree (reg_list_dead rl live) (Regmap.init Vundef) ls ->
+ Val.lessdef_list vl (List.map ls (List.map assign rl)) ->
agree live (init_regs vl rl) ls.
Proof.
induction rl; simpl; intros.
- assumption.
- destruct vl. discriminate.
- assert (agree (reg_dead a live) (init_regs vl rl) ls).
- apply IHrl. intros. apply H. tauto.
- eapply Regset.remove_3; eauto.
- auto. congruence. assumption.
+ red; intros. rewrite Regmap.gi. auto.
+ inv H0.
+ assert (agree live (init_regs vl1 rl) ls).
+ apply IHrl. intros. apply H. tauto. auto. auto. auto.
red; intros. case (Reg.eq a r); intro.
- subst r. rewrite Regmap.gss. congruence.
- rewrite Regmap.gso; auto. apply H2.
- apply Regset.remove_2; auto.
+ subst r. rewrite Regmap.gss. auto.
+ rewrite Regmap.gso; auto.
Qed.
Lemma agree_parameters:
forall vl ls,
let params := f.(RTL.fn_params) in
- List.map ls (List.map assign params) = vl ->
- (forall r,
- Regset.In r (reg_list_dead params (live0 f flive)) ->
- ls (assign r) = Vundef) ->
- agree (live0 f flive) (init_regs vl params) ls.
+ Val.lessdef_list vl (List.map ls (List.map assign params)) ->
+ agree (live0 f flive)
+ (init_regs vl params)
+ ls.
Proof.
intros. apply agree_init_regs.
intros. eapply regalloc_correct_3; eauto.
- assumption.
- red; intros. rewrite Regmap.gi. auto.
-Qed.
-
-End AGREE.
-
-(** * Correctness of the LTL constructors *)
-
-(** This section proves theorems that establish the correctness of the
- LTL constructor functions such as [add_op]. The theorems are of
- the general form ``the generated LTL instructions execute and
- modify the location set in the expected way: the result location(s)
- contain the expected values and other, non-temporary locations keep
- their values''. *)
-
-Section LTL_CONSTRUCTORS.
-
-Variable ge: LTL.genv.
-Variable sp: val.
-
-Lemma reg_for_spec:
- forall l,
- R(reg_for l) = l \/ In (R (reg_for l)) temporaries.
-Proof.
- intros. unfold reg_for. destruct l. tauto.
- case (slot_type s); simpl; tauto.
-Qed.
-
-Lemma add_reload_correct:
- forall src dst k rs m,
- exists rs',
- exec_instrs ge sp (add_reload src dst k) rs m E0 k rs' m /\
- rs' (R dst) = rs src /\
- forall l, Loc.diff (R dst) l -> rs' l = rs l.
-Proof.
- intros. unfold add_reload. destruct src.
- case (mreg_eq m0 dst); intro.
- subst dst. exists rs. split. apply exec_refl. tauto.
- exists (Locmap.set (R dst) (rs (R m0)) rs).
- split. apply exec_one; apply exec_Bop. reflexivity.
- split. apply Locmap.gss.
- intros; apply Locmap.gso; auto.
- exists (Locmap.set (R dst) (rs (S s)) rs).
- split. apply exec_one; apply exec_Bgetstack.
- split. apply Locmap.gss.
- intros; apply Locmap.gso; auto.
-Qed.
-
-Lemma add_spill_correct:
- forall src dst k rs m,
- exists rs',
- exec_instrs ge sp (add_spill src dst k) rs m E0 k rs' m /\
- rs' dst = rs (R src) /\
- forall l, Loc.diff dst l -> rs' l = rs l.
-Proof.
- intros. unfold add_spill. destruct dst.
- case (mreg_eq src m0); intro.
- subst src. exists rs. split. apply exec_refl. tauto.
- exists (Locmap.set (R m0) (rs (R src)) rs).
- split. apply exec_one. apply exec_Bop. reflexivity.
- split. apply Locmap.gss.
- intros; apply Locmap.gso; auto.
- exists (Locmap.set (S s) (rs (R src)) rs).
- split. apply exec_one. apply exec_Bsetstack.
- split. apply Locmap.gss.
- intros; apply Locmap.gso; auto.
-Qed.
-
-Lemma add_reloads_correct_rec:
- forall srcs itmps ftmps k rs m,
- (List.length srcs <= List.length itmps)%nat ->
- (List.length srcs <= List.length ftmps)%nat ->
- (forall r, In (R r) srcs -> In r itmps -> False) ->
- (forall r, In (R r) srcs -> In r ftmps -> False) ->
- list_disjoint itmps ftmps ->
- list_norepet itmps ->
- list_norepet ftmps ->
- exists rs',
- exec_instrs ge sp (add_reloads srcs (regs_for_rec srcs itmps ftmps) k) rs m E0 k rs' m /\
- reglist (regs_for_rec srcs itmps ftmps) rs' = map rs srcs /\
- (forall r, ~(In r itmps) -> ~(In r ftmps) -> rs' (R r) = rs (R r)) /\
- (forall s, rs' (S s) = rs (S s)).
-Proof.
- induction srcs; simpl; intros.
- (* base case *)
- exists rs. split. apply exec_refl. tauto.
- (* inductive case *)
- destruct itmps; simpl in H. omegaContradiction.
- destruct ftmps; simpl in H0. omegaContradiction.
- assert (R1: (length srcs <= length itmps)%nat). omega.
- assert (R2: (length srcs <= length ftmps)%nat). omega.
- assert (R3: forall r, In (R r) srcs -> In r itmps -> False).
- intros. apply H1 with r. tauto. auto with coqlib.
- assert (R4: forall r, In (R r) srcs -> In r ftmps -> False).
- intros. apply H2 with r. tauto. auto with coqlib.
- assert (R5: list_disjoint itmps ftmps).
- eapply list_disjoint_cons_left.
- eapply list_disjoint_cons_right. eauto.
- assert (R6: list_norepet itmps).
- inversion H4; auto.
- assert (R7: list_norepet ftmps).
- inversion H5; auto.
- destruct a.
- (* a is a register *)
- generalize (IHsrcs itmps ftmps k rs m R1 R2 R3 R4 R5 R6 R7).
- intros [rs' [EX [RES [OTH1 OTH2]]]].
- exists rs'. split.
- unfold add_reload. case (mreg_eq m2 m2); intro; tauto.
- split. simpl. apply (f_equal2 (@cons val)).
- apply OTH1.
- red; intro; apply H1 with m2. tauto. auto with coqlib.
- red; intro; apply H2 with m2. tauto. auto with coqlib.
- assumption.
- split. intros. apply OTH1. simpl in H6; tauto. simpl in H7; tauto.
- auto.
- (* a is a stack location *)
- set (tmp := match slot_type s with Tint => m0 | Tfloat => m1 end).
- assert (NI: ~(In tmp itmps)).
- unfold tmp; case (slot_type s).
- inversion H4; auto.
- apply list_disjoint_notin with (m1 :: ftmps).
- apply list_disjoint_sym. apply list_disjoint_cons_left with m0.
- auto. auto with coqlib.
- assert (NF: ~(In tmp ftmps)).
- unfold tmp; case (slot_type s).
- apply list_disjoint_notin with (m0 :: itmps).
- apply list_disjoint_cons_right with m1.
- auto. auto with coqlib.
- inversion H5; auto.
- generalize
- (add_reload_correct (S s) tmp
- (add_reloads srcs (regs_for_rec srcs itmps ftmps) k) rs m).
- intros [rs1 [EX1 [RES1 OTH]]].
- generalize (IHsrcs itmps ftmps k rs1 m R1 R2 R3 R4 R5 R6 R7).
- intros [rs' [EX [RES [OTH1 OTH2]]]].
- exists rs'.
- split. eapply exec_trans; eauto. traceEq.
- split. simpl. apply (f_equal2 (@cons val)).
- rewrite OTH1; auto.
- rewrite RES. apply list_map_exten. intros.
- symmetry. apply OTH.
- destruct x; try exact I. simpl. red; intro; subst m2.
- generalize H6; unfold tmp. case (slot_type s).
- intro. apply H1 with m0. tauto. auto with coqlib.
- intro. apply H2 with m1. tauto. auto with coqlib.
- split. intros. simpl in H6; simpl in H7.
- rewrite OTH1. apply OTH.
- simpl. unfold tmp. case (slot_type s); tauto.
- tauto. tauto.
- intros. rewrite OTH2. apply OTH. exact I.
-Qed.
-
-Lemma add_reloads_correct:
- forall srcs k rs m,
- (List.length srcs <= 3)%nat ->
- Loc.disjoint srcs temporaries ->
- exists rs',
- exec_instrs ge sp (add_reloads srcs (regs_for srcs) k) rs m E0 k rs' m /\
- reglist (regs_for srcs) rs' = List.map rs srcs /\
- forall l, Loc.notin l temporaries -> rs' l = rs l.
-Proof.
- intros.
- pose (itmps := IT1 :: IT2 :: IT3 :: nil).
- pose (ftmps := FT1 :: FT2 :: FT3 :: nil).
- assert (R1: (List.length srcs <= List.length itmps)%nat).
- unfold itmps; simpl; assumption.
- assert (R2: (List.length srcs <= List.length ftmps)%nat).
- unfold ftmps; simpl; assumption.
- assert (R3: forall r, In (R r) srcs -> In r itmps -> False).
- intros. assert (In (R r) temporaries).
- simpl in H2; simpl; intuition congruence.
- generalize (H0 _ _ H1 H3). simpl. tauto.
- assert (R4: forall r, In (R r) srcs -> In r ftmps -> False).
- intros. assert (In (R r) temporaries).
- simpl in H2; simpl; intuition congruence.
- generalize (H0 _ _ H1 H3). simpl. tauto.
- assert (R5: list_disjoint itmps ftmps).
- red; intros r1 r2; simpl; intuition congruence.
- assert (R6: list_norepet itmps).
- unfold itmps. NoRepet.
- assert (R7: list_norepet ftmps).
- unfold ftmps. NoRepet.
- generalize (add_reloads_correct_rec srcs itmps ftmps k rs m
- R1 R2 R3 R4 R5 R6 R7).
- intros [rs' [EX [RES [OTH1 OTH2]]]].
- exists rs'. split. exact EX.
- split. exact RES.
- intros. destruct l. apply OTH1.
- generalize (Loc.notin_not_in _ _ H1). simpl. intuition congruence.
- generalize (Loc.notin_not_in _ _ H1). simpl. intuition congruence.
- apply OTH2.
-Qed.
-
-Lemma add_move_correct:
- forall src dst k rs m,
- exists rs',
- exec_instrs ge sp (add_move src dst k) rs m E0 k rs' m /\
- rs' dst = rs src /\
- forall l, Loc.diff l dst -> Loc.diff l (R IT1) -> Loc.diff l (R FT1) -> rs' l = rs l.
-Proof.
- intros; unfold add_move.
- case (Loc.eq src dst); intro.
- subst dst. exists rs. split. apply exec_refl. tauto.
- destruct src.
- (* src is a register *)
- generalize (add_spill_correct m0 dst k rs m); intros [rs' [EX [RES OTH]]].
- exists rs'; intuition. apply OTH; apply Loc.diff_sym; auto.
- destruct dst.
- (* src is a stack slot, dst a register *)
- generalize (add_reload_correct (S s) m0 k rs m); intros [rs' [EX [RES OTH]]].
- exists rs'; intuition. apply OTH; apply Loc.diff_sym; auto.
- (* src and dst are stack slots *)
- set (tmp := match slot_type s with Tint => IT1 | Tfloat => FT1 end).
- generalize (add_reload_correct (S s) tmp (add_spill tmp (S s0) k) rs m);
- intros [rs1 [EX1 [RES1 OTH1]]].
- generalize (add_spill_correct tmp (S s0) k rs1 m);
- intros [rs2 [EX2 [RES2 OTH2]]].
- exists rs2. split.
- eapply exec_trans; eauto. traceEq.
- split. congruence.
- intros. rewrite OTH2. apply OTH1.
- apply Loc.diff_sym. unfold tmp; case (slot_type s); auto.
- apply Loc.diff_sym; auto.
-Qed.
-
-Lemma effect_move_sequence:
- forall k moves rs m,
- let k' := List.fold_right (fun p k => add_move (fst p) (snd p) k) k moves in
- exists rs',
- exec_instrs ge sp k' rs m E0 k rs' m /\
- effect_seqmove moves rs rs'.
-Proof.
- induction moves; intros until m; simpl.
- exists rs; split. constructor. constructor.
- destruct a as [src dst]; simpl.
- set (k1 := fold_right
- (fun (p : loc * loc) (k : block) => add_move (fst p) (snd p) k)
- k moves) in *.
- destruct (add_move_correct src dst k1 rs m) as [rs1 [A [B C]]].
- destruct (IHmoves rs1 m) as [rs' [D E]].
- exists rs'; split.
- eapply exec_trans; eauto. traceEq.
- econstructor; eauto. red. tauto.
-Qed.
-
-Theorem parallel_move_correct:
- forall srcs dsts k rs m,
- List.length srcs = List.length dsts ->
- Loc.no_overlap srcs dsts ->
- Loc.norepet dsts ->
- Loc.disjoint srcs temporaries ->
- Loc.disjoint dsts temporaries ->
- exists rs',
- exec_instrs ge sp (parallel_move srcs dsts k) rs m E0 k rs' m /\
- List.map rs' dsts = List.map rs srcs /\
- rs' (R IT3) = rs (R IT3) /\
- forall l, Loc.notin l dsts -> Loc.notin l temporaries -> rs' l = rs l.
-Proof.
- intros.
- generalize (effect_move_sequence k (parmove srcs dsts) rs m).
- intros [rs' [EXEC EFFECT]].
- exists rs'. split. exact EXEC.
- apply effect_parmove; auto.
-Qed.
-
-Lemma add_op_correct:
- forall op args res s rs m v,
- (List.length args <= 3)%nat ->
- Loc.disjoint args temporaries ->
- eval_operation ge sp op (List.map rs args) = Some v ->
- exists rs',
- exec_block ge sp (add_op op args res s) rs m E0 (Cont s) rs' m /\
- rs' res = v /\
- forall l, Loc.diff l res -> Loc.notin l temporaries -> rs' l = rs l.
-Proof.
- intros. unfold add_op.
- caseEq (is_move_operation op args).
- (* move *)
- intros arg IMO.
- generalize (is_move_operation_correct op args IMO).
- intros [EQ1 EQ2]. subst op; subst args.
- generalize (add_move_correct arg res (Bgoto s) rs m).
- intros [rs' [EX [RES OTHER]]].
- exists rs'. split.
- apply exec_Bgoto. exact EX.
- split. simpl in H1. congruence.
- intros. unfold temporaries in H3; simpl in H3.
- apply OTHER. assumption. tauto. tauto.
- (* other ops *)
- intros.
- set (rargs := regs_for args). set (rres := reg_for res).
- generalize (add_reloads_correct args
- (Bop op rargs rres (add_spill rres res (Bgoto s)))
- rs m H H0).
- intros [rs1 [EX1 [RES1 OTHER1]]].
- pose (rs2 := Locmap.set (R rres) v rs1).
- generalize (add_spill_correct rres res (Bgoto s) rs2 m).
- intros [rs3 [EX3 [RES3 OTHER3]]].
- exists rs3.
- split. apply exec_Bgoto. eapply exec_trans. eexact EX1.
- eapply exec_trans; eauto.
- apply exec_one. unfold rs2. apply exec_Bop.
- unfold rargs. rewrite RES1. auto. traceEq.
- split. rewrite RES3. unfold rs2; apply Locmap.gss.
- intros. rewrite OTHER3. unfold rs2. rewrite Locmap.gso.
- apply OTHER1. assumption.
- apply Loc.diff_sym. unfold rres. elim (reg_for_spec res); intro.
- rewrite H5; auto.
- eapply Loc.in_notin_diff; eauto. apply Loc.diff_sym; auto.
-Qed.
-
-Lemma add_load_correct:
- forall chunk addr args res s rs m a v,
- (List.length args <= 2)%nat ->
- Loc.disjoint args temporaries ->
- eval_addressing ge sp addr (List.map rs args) = Some a ->
- loadv chunk m a = Some v ->
- exists rs',
- exec_block ge sp (add_load chunk addr args res s) rs m E0 (Cont s) rs' m /\
- rs' res = v /\
- forall l, Loc.diff l res -> Loc.notin l temporaries -> rs' l = rs l.
-Proof.
- intros. unfold add_load.
- set (rargs := regs_for args). set (rres := reg_for res).
- assert (LL: (List.length args <= 3)%nat). omega.
- generalize (add_reloads_correct args
- (Bload chunk addr rargs rres (add_spill rres res (Bgoto s)))
- rs m LL H0).
- intros [rs1 [EX1 [RES1 OTHER1]]].
- pose (rs2 := Locmap.set (R rres) v rs1).
- generalize (add_spill_correct rres res (Bgoto s) rs2 m).
- intros [rs3 [EX3 [RES3 OTHER3]]].
- exists rs3.
- split. apply exec_Bgoto. eapply exec_trans; eauto.
- eapply exec_trans; eauto.
- apply exec_one. unfold rs2. apply exec_Bload with a.
- unfold rargs; rewrite RES1. assumption. assumption. traceEq.
- split. rewrite RES3. unfold rs2; apply Locmap.gss.
- intros. rewrite OTHER3. unfold rs2. rewrite Locmap.gso.
- apply OTHER1. assumption.
- apply Loc.diff_sym. unfold rres. elim (reg_for_spec res); intro.
- rewrite H5; auto.
- eapply Loc.in_notin_diff; eauto. apply Loc.diff_sym; auto.
-Qed.
-
-Lemma add_store_correct:
- forall chunk addr args src s rs m m' a,
- (List.length args <= 2)%nat ->
- Loc.disjoint args temporaries ->
- Loc.notin src temporaries ->
- eval_addressing ge sp addr (List.map rs args) = Some a ->
- storev chunk m a (rs src) = Some m' ->
- exists rs',
- exec_block ge sp (add_store chunk addr args src s) rs m E0 (Cont s) rs' m' /\
- forall l, Loc.notin l temporaries -> rs' l = rs l.
-Proof.
- intros.
- assert (LL: (List.length (src :: args) <= 3)%nat).
- simpl. omega.
- assert (DISJ: Loc.disjoint (src :: args) temporaries).
- red; intros. elim H4; intro. subst x1.
- eapply Loc.in_notin_diff; eauto.
- auto with coqlib.
- unfold add_store. caseEq (regs_for (src :: args)).
- unfold regs_for; simpl; intro; discriminate.
- intros rsrc rargs EQ.
- generalize (add_reloads_correct (src :: args)
- (Bstore chunk addr rargs rsrc (Bgoto s))
- rs m LL DISJ).
- intros [rs1 [EX1 [RES1 OTHER1]]].
- rewrite EQ in RES1. simpl in RES1. injection RES1.
- intros RES2 RES3.
- exists rs1.
- split. apply exec_Bgoto.
- eapply exec_trans. rewrite <- EQ. eexact EX1.
- apply exec_one. apply exec_Bstore with a.
- rewrite RES2. assumption. rewrite RES3. assumption. traceEq.
- exact OTHER1.
-Qed.
-
-Lemma add_alloc_correct:
- forall arg res s rs m m' sz b,
- rs arg = Vint sz ->
- Mem.alloc m 0 (Int.signed sz) = (m', b) ->
- exists rs',
- exec_block ge sp (add_alloc arg res s) rs m E0 (Cont s) rs' m' /\
- rs' res = Vptr b Int.zero /\
- forall l,
- Loc.diff l (R Conventions.loc_alloc_argument) ->
- Loc.diff l (R Conventions.loc_alloc_result) ->
- Loc.diff l res ->
- rs' l = rs l.
-Proof.
- intros; unfold add_alloc.
- generalize (add_reload_correct arg loc_alloc_argument
- (Balloc (add_spill loc_alloc_result res (Bgoto s)))
- rs m).
- intros [rs1 [EX1 [RES1 OTHER1]]].
- pose (rs2 := Locmap.set (R loc_alloc_result) (Vptr b Int.zero) rs1).
- generalize (add_spill_correct loc_alloc_result res (Bgoto s) rs2 m').
- intros [rs3 [EX3 [RES3 OTHER3]]].
- exists rs3.
- split. apply exec_Bgoto. eapply exec_trans. eexact EX1.
- eapply exec_trans. apply exec_one. eapply exec_Balloc; eauto. congruence.
- fold rs2. eexact EX3. reflexivity. traceEq.
- split. rewrite RES3; unfold rs2. apply Locmap.gss.
- intros. rewrite OTHER3. unfold rs2. rewrite Locmap.gso.
- apply OTHER1. apply Loc.diff_sym; auto.
- apply Loc.diff_sym; auto.
- apply Loc.diff_sym; auto.
-Qed.
-
-Lemma add_cond_correct:
- forall cond args ifso ifnot rs m b s,
- (List.length args <= 3)%nat ->
- Loc.disjoint args temporaries ->
- eval_condition cond (List.map rs args) = Some b ->
- s = (if b then ifso else ifnot) ->
- exists rs',
- exec_block ge sp (add_cond cond args ifso ifnot) rs m E0 (Cont s) rs' m /\
- forall l, Loc.notin l temporaries -> rs' l = rs l.
-Proof.
- intros. unfold add_cond.
- set (rargs := regs_for args).
- generalize (add_reloads_correct args
- (Bcond cond rargs ifso ifnot)
- rs m H H0).
- intros [rs1 [EX1 [RES1 OTHER1]]].
- fold rargs in EX1.
- exists rs1.
- split. destruct b; subst s.
- eapply exec_Bcond_true. eexact EX1.
- unfold rargs; rewrite RES1. assumption.
- eapply exec_Bcond_false. eexact EX1.
- unfold rargs; rewrite RES1. assumption.
- exact OTHER1.
-Qed.
-
-Definition find_function2 (los: loc + ident) (ls: locset) : option fundef :=
- match los with
- | inl l => Genv.find_funct ge (ls l)
- | inr symb =>
- match Genv.find_symbol ge symb with
- | None => None
- | Some b => Genv.find_funct_ptr ge b
- end
- end.
-
-Lemma add_call_correct:
- forall f vargs m t vres m' sig los args res s ls
- (EXECF:
- forall lsi,
- List.map lsi (loc_arguments (funsig f)) = vargs ->
- exists lso,
- exec_function ge f lsi m t lso m'
- /\ lso (R (loc_result (funsig f))) = vres)
- (FIND: find_function2 los ls = Some f)
- (SIG: sig = funsig f)
- (VARGS: List.map ls args = vargs)
- (LARGS: List.length args = List.length sig.(sig_args))
- (AARGS: locs_acceptable args)
- (RES: loc_acceptable res),
- exists ls',
- exec_block ge sp (add_call sig los args res s) ls m t (Cont s) ls' m' /\
- ls' res = vres /\
- forall l,
- Loc.notin l destroyed_at_call -> loc_acceptable l -> Loc.diff l res ->
- ls' l = ls l.
-Proof.
- intros until los.
- case los; intro fn; intros; simpl in FIND; rewrite <- SIG in EXECF; unfold add_call.
- (* indirect call *)
- assert (LEN: List.length args = List.length (loc_arguments sig)).
- rewrite LARGS. symmetry. apply loc_arguments_length.
- pose (DISJ := locs_acceptable_disj_temporaries args AARGS).
- generalize (add_reload_correct fn IT3
- (parallel_move args (loc_arguments sig)
- (Bcall sig (inl ident IT3)
- (add_spill (loc_result sig) res (Bgoto s))))
- ls m).
- intros [ls1 [EX1 [RES1 OTHER1]]].
- generalize
- (parallel_move_correct args (loc_arguments sig)
- (Bcall sig (inl ident IT3)
- (add_spill (loc_result sig) res (Bgoto s)))
- ls1 m LEN
- (no_overlap_arguments args sig AARGS)
- (loc_arguments_norepet sig)
- DISJ
- (loc_arguments_not_temporaries sig)).
- intros [ls2 [EX2 [RES2 [TMP2 OTHER2]]]].
- assert (PARAMS: List.map ls2 (loc_arguments sig) = vargs).
- rewrite <- VARGS. rewrite RES2.
- apply list_map_exten. intros. symmetry. apply OTHER1.
- apply Loc.diff_sym. apply DISJ. auto. simpl; tauto.
- generalize (EXECF ls2 PARAMS).
- intros [ls3 [EX3 RES3]].
- pose (ls4 := return_regs ls2 ls3).
- generalize (add_spill_correct (loc_result sig) res
- (Bgoto s) ls4 m').
- intros [ls5 [EX5 [RES5 OTHER5]]].
- exists ls5.
- (* Execution *)
- split. apply exec_Bgoto.
- eapply exec_trans. eexact EX1.
- eapply exec_trans. eexact EX2.
- eapply exec_trans. apply exec_one. apply exec_Bcall with f.
- unfold find_function. rewrite TMP2. rewrite RES1.
- assumption. assumption. eexact EX3.
- eexact EX5. reflexivity. reflexivity. traceEq.
- (* Result *)
- split. rewrite RES5. unfold ls4. rewrite return_regs_result.
- assumption.
- (* Other regs *)
- intros. rewrite OTHER5; auto.
- unfold ls4; rewrite return_regs_not_destroyed; auto.
- rewrite OTHER2. apply OTHER1.
- apply Loc.diff_sym. apply Loc.in_notin_diff with temporaries.
- apply temporaries_not_acceptable; auto. simpl; tauto.
- apply arguments_not_preserved; auto.
- apply temporaries_not_acceptable; auto.
- apply Loc.diff_sym; auto.
- (* direct call *)
- assert (LEN: List.length args = List.length (loc_arguments sig)).
- rewrite LARGS. symmetry. apply loc_arguments_length.
- pose (DISJ := locs_acceptable_disj_temporaries args AARGS).
- generalize
- (parallel_move_correct args (loc_arguments sig)
- (Bcall sig (inr mreg fn)
- (add_spill (loc_result sig) res (Bgoto s)))
- ls m LEN
- (no_overlap_arguments args sig AARGS)
- (loc_arguments_norepet sig)
- DISJ (loc_arguments_not_temporaries sig)).
- intros [ls2 [EX2 [RES2 [TMP2 OTHER2]]]].
- assert (PARAMS: List.map ls2 (loc_arguments sig) = vargs).
- rewrite <- VARGS. rewrite RES2. auto.
- generalize (EXECF ls2 PARAMS).
- intros [ls3 [EX3 RES3]].
- pose (ls4 := return_regs ls2 ls3).
- generalize (add_spill_correct (loc_result sig) res
- (Bgoto s) ls4 m').
- intros [ls5 [EX5 [RES5 OTHER5]]].
- exists ls5.
- (* Execution *)
- split. apply exec_Bgoto.
- eapply exec_trans. eexact EX2.
- eapply exec_trans. apply exec_one. apply exec_Bcall with f.
- unfold find_function. assumption. assumption. eexact EX3.
- eexact EX5. reflexivity. traceEq.
- (* Result *)
- split. rewrite RES5.
- unfold ls4. rewrite return_regs_result.
- assumption.
- (* Other regs *)
- intros. rewrite OTHER5; auto.
- unfold ls4; rewrite return_regs_not_destroyed; auto.
- apply OTHER2.
- apply arguments_not_preserved; auto.
- apply temporaries_not_acceptable; auto.
- apply Loc.diff_sym; auto.
-Qed.
-
-Lemma add_undefs_correct:
- forall res b ls m,
- (forall l, In l res -> loc_acceptable l) ->
- (forall ofs ty, In (S (Local ofs ty)) res -> ls (S (Local ofs ty)) = Vundef) ->
- exists ls',
- exec_instrs ge sp (add_undefs res b) ls m E0 b ls' m /\
- (forall l, In l res -> ls' l = Vundef) /\
- (forall l, Loc.notin l res -> ls' l = ls l).
-Proof.
- induction res; simpl; intros.
- exists ls. split. apply exec_refl. tauto.
- assert (ACC: forall l, In l res -> loc_acceptable l).
- intros. apply H. tauto.
- destruct a.
- (* a is a register *)
- pose (ls1 := Locmap.set (R m0) Vundef ls).
- assert (UNDEFS: forall ofs ty, In (S (Local ofs ty)) res -> ls1 (S (Local ofs ty)) = Vundef).
- intros. unfold ls1; rewrite Locmap.gso. auto. red; auto.
- generalize (IHres b (Locmap.set (R m0) Vundef ls) m ACC UNDEFS).
- intros [ls2 [EX2 [RES2 OTHER2]]].
- exists ls2. split.
- eapply exec_trans. apply exec_one. apply exec_Bop.
- simpl; reflexivity. eexact EX2. traceEq.
- split. intros. case (In_dec Loc.eq l res); intro.
- apply RES2; auto.
- rewrite OTHER2. elim H1; intro.
- subst l. apply Locmap.gss.
- contradiction.
- apply loc_acceptable_notin_notin; auto.
- intros. rewrite OTHER2. apply Locmap.gso.
- apply Loc.diff_sym; tauto. tauto.
- (* a is a stack location *)
- assert (UNDEFS: forall ofs ty, In (S (Local ofs ty)) res -> ls (S (Local ofs ty)) = Vundef).
- intros. apply H0. tauto.
- generalize (IHres b ls m ACC UNDEFS).
- intros [ls2 [EX2 [RES2 OTHER2]]].
- exists ls2. split. assumption.
- split. intros. case (In_dec Loc.eq l res); intro.
auto.
- rewrite OTHER2. elim H1; intro.
- subst l. generalize (H (S s) (in_eq _ _)).
- unfold loc_acceptable; destruct s; intuition auto.
- contradiction.
- apply loc_acceptable_notin_notin; auto.
- intros. apply OTHER2. tauto.
-Qed.
-
-Lemma add_entry_correct:
- forall sig params undefs s ls m,
- List.length params = List.length sig.(sig_args) ->
- Loc.norepet params ->
- locs_acceptable params ->
- Loc.disjoint params undefs ->
- locs_acceptable undefs ->
- (forall ofs ty, ls (S (Local ofs ty)) = Vundef) ->
- exists ls',
- exec_block ge sp (add_entry sig params undefs s) ls m E0 (Cont s) ls' m /\
- List.map ls' params = List.map ls (loc_parameters sig) /\
- (forall l, In l undefs -> ls' l = Vundef).
-Proof.
- intros.
- assert (List.length (loc_parameters sig) = List.length params).
- unfold loc_parameters. rewrite list_length_map.
- rewrite loc_arguments_length. auto.
- assert (DISJ: Loc.disjoint params temporaries).
- apply locs_acceptable_disj_temporaries; auto.
- generalize (parallel_move_correct _ _ (add_undefs undefs (Bgoto s))
- ls m H5
- (no_overlap_parameters _ _ H1)
- H0 (loc_parameters_not_temporaries sig) DISJ).
- intros [ls1 [EX1 [RES1 [TMP1 OTHER1]]]].
- assert (forall ofs ty, In (S (Local ofs ty)) undefs -> ls1 (S (Local ofs ty)) = Vundef).
- intros. rewrite OTHER1. auto. apply Loc.disjoint_notin with undefs.
- apply Loc.disjoint_sym. auto. auto.
- simpl; tauto.
- generalize (add_undefs_correct undefs (Bgoto s) ls1 m H3 H6).
- intros [ls2 [EX2 [RES2 OTHER2]]].
- exists ls2.
- split. apply exec_Bgoto. unfold add_entry.
- eapply exec_trans. eexact EX1. eexact EX2. traceEq.
- split. rewrite <- RES1. apply list_map_exten.
- intros. symmetry. apply OTHER2. eapply Loc.disjoint_notin; eauto.
- exact RES2.
-Qed.
-
-Lemma add_return_correct:
- forall sig optarg ls m,
- exists ls',
- exec_block ge sp (add_return sig optarg) ls m E0 Return ls' m /\
- match optarg with
- | Some arg => ls' (R (loc_result sig)) = ls arg
- | None => ls' (R (loc_result sig)) = Vundef
- end.
-Proof.
- intros. unfold add_return.
- destruct optarg.
- generalize (add_reload_correct l (loc_result sig) Breturn ls m).
- intros [ls1 [EX1 [RES1 OTH1]]].
- exists ls1.
- split. apply exec_Breturn. assumption. assumption.
- exists (Locmap.set (R (loc_result sig)) Vundef ls).
- split. apply exec_Breturn. apply exec_one.
- apply exec_Bop. reflexivity. apply Locmap.gss.
-Qed.
-
-End LTL_CONSTRUCTORS.
-
-(** * Exploitation of the typing hypothesis *)
-
-(** Register allocation is applied to RTL code that passed type inference
- (see file [RTLtyping]), and therefore is well-typed in the type system
- of [RTLtyping]. We exploit this hypothesis to obtain information on
- the number of arguments to operations, addressing modes and conditions. *)
-
-Remark length_type_of_condition:
- forall (c: condition), (List.length (type_of_condition c) <= 3)%nat.
-Proof.
- destruct c; unfold type_of_condition; simpl; omega.
-Qed.
-
-Remark length_type_of_operation:
- forall (op: operation), (List.length (fst (type_of_operation op)) <= 3)%nat.
-Proof.
- destruct op; unfold type_of_operation; simpl; try omega.
- apply length_type_of_condition.
-Qed.
-
-Remark length_type_of_addressing:
- forall (addr: addressing), (List.length (type_of_addressing addr) <= 2)%nat.
-Proof.
- destruct addr; unfold type_of_addressing; simpl; omega.
Qed.
-Lemma length_op_args:
- forall (env: regenv) (op: operation) (args: list reg) (res: reg),
- (List.map env args, env res) = type_of_operation op ->
- (List.length args <= 3)%nat.
-Proof.
- intros. rewrite <- (list_length_map env).
- generalize (length_type_of_operation op).
- rewrite <- H. simpl. auto.
-Qed.
-
-Lemma length_addr_args:
- forall (env: regenv) (addr: addressing) (args: list reg),
- List.map env args = type_of_addressing addr ->
- (List.length args <= 2)%nat.
-Proof.
- intros. rewrite <- (list_length_map env).
- rewrite H. apply length_type_of_addressing.
-Qed.
-
-Lemma length_cond_args:
- forall (env: regenv) (cond: condition) (args: list reg),
- List.map env args = type_of_condition cond ->
- (List.length args <= 3)%nat.
-Proof.
- intros. rewrite <- (list_length_map env).
- rewrite H. apply length_type_of_condition.
-Qed.
+End AGREE.
(** * Preservation of semantics *)
@@ -1176,7 +477,7 @@ Section PRESERVATION.
Variable prog: RTL.program.
Variable tprog: LTL.program.
-Hypothesis TRANSF: transf_program prog = Some tprog.
+Hypothesis TRANSF: transf_program prog = OK tprog.
Let ge := Genv.globalenv prog.
Let tge := Genv.globalenv tprog.
@@ -1193,740 +494,460 @@ Lemma functions_translated:
forall (v: val) (f: RTL.fundef),
Genv.find_funct ge v = Some f ->
exists tf,
- Genv.find_funct tge v = Some tf /\ transf_fundef f = Some tf.
-Proof.
- intros.
- generalize
- (Genv.find_funct_transf_partial transf_fundef TRANSF H).
- case (transf_fundef f).
- intros tf [A B]. exists tf. tauto.
- intros [A B]. elim B. reflexivity.
-Qed.
+ Genv.find_funct tge v = Some tf /\ transf_fundef f = OK tf.
+Proof (Genv.find_funct_transf_partial transf_fundef TRANSF).
Lemma function_ptr_translated:
- forall (b: Values.block) (f: RTL.fundef),
+ forall (b: block) (f: RTL.fundef),
Genv.find_funct_ptr ge b = Some f ->
exists tf,
- Genv.find_funct_ptr tge b = Some tf /\ transf_fundef f = Some tf.
-Proof.
- intros.
- generalize
- (Genv.find_funct_ptr_transf_partial transf_fundef TRANSF H).
- case (transf_fundef f).
- intros tf [A B]. exists tf. tauto.
- intros [A B]. elim B. reflexivity.
-Qed.
+ Genv.find_funct_ptr tge b = Some tf /\ transf_fundef f = OK tf.
+Proof (Genv.find_funct_ptr_transf_partial transf_fundef TRANSF).
Lemma sig_function_translated:
forall f tf,
- transf_fundef f = Some tf ->
+ transf_fundef f = OK tf ->
LTL.funsig tf = RTL.funsig f.
Proof.
- intros f tf. destruct f; simpl.
+ intros f tf. destruct f; simpl.
unfold transf_function.
destruct (type_function f).
destruct (analyze f).
- destruct (regalloc f t).
- intro EQ; injection EQ; intro EQ1; rewrite <- EQ1; simpl; auto.
- congruence. congruence. congruence.
- intro EQ; inversion EQ; subst tf. reflexivity.
-Qed.
-
-Lemma entrypoint_function_translated:
- forall f tf,
- transf_function f = Some tf ->
- tf.(LTL.fn_entrypoint) = f.(RTL.fn_nextpc).
-Proof.
- intros f tf. unfold transf_function.
- destruct (type_function f).
- destruct (analyze f).
- destruct (regalloc f t).
- intro EQ; injection EQ; intro EQ1; rewrite <- EQ1; simpl; auto.
- intros; discriminate.
- intros; discriminate.
- intros; discriminate.
+ destruct (regalloc f t).
+ intro. monadInv H. inv EQ. auto.
+ simpl; congruence. simpl; congruence. simpl; congruence.
+ intro EQ; inv EQ. auto.
Qed.
(** The proof of semantic preservation is a simulation argument
based on diagrams of the following form:
<<
- pc, rs, m ------------------- pc, ls, m
- | |
- | |
- v v
- pc', rs', m' ---------------- Cont pc', ls', m'
+ st1 --------------- st2
+ | |
+ t| |t
+ | |
+ v v
+ st1'--------------- st2'
>>
Hypotheses: the left vertical arrow represents a transition in the
- original RTL code. The top horizontal bar expresses agreement between
- [rs] and [ls] over the pseudo-registers live before the RTL instruction
- at [pc].
+ original RTL code. The top horizontal bar is the [match_states]
+ relation defined below. It implies agreement between
+ the RTL register map [rs] and the LTL location map [ls]
+ over the pseudo-registers live before the RTL instruction at [pc].
- Conclusions: the right vertical arrow is an [exec_blocks] transition
+ Conclusions: the right vertical arrow is an [exec_instrs] transition
in the LTL code generated by translation of the current function.
- The bottom horizontal bar expresses agreement between [rs'] and [ls']
- over the pseudo-registers live after the RTL instruction at [pc]
- (which implies agreement over the pseudo-registers live before
- the instruction at [pc']).
-
- We capture these diagrams in the following propositions parameterized
- by the transition in the original RTL code (the left arrow).
+ The bottom horizontal bar is the [match_states] relation.
*)
-Definition exec_instr_prop
- (c: RTL.code) (sp: val)
- (pc: node) (rs: regset) (m: mem) (t: trace)
- (pc': node) (rs': regset) (m': mem) : Prop :=
- forall f env live assign ls
- (CF: c = f.(RTL.fn_code))
- (WT: wt_function f env)
- (ASG: regalloc f live (live0 f live) env = Some assign)
- (AG: agree assign (transfer f pc live!!pc) rs ls),
- let tc := PTree.map (transf_instr f live assign) c in
- exists ls',
- exec_blocks tge tc sp pc ls m t (Cont pc') ls' m' /\
- agree assign live!!pc rs' ls'.
-
-Definition exec_instrs_prop
- (c: RTL.code) (sp: val)
- (pc: node) (rs: regset) (m: mem) (t: trace)
- (pc': node) (rs': regset) (m': mem) : Prop :=
- forall f env live assign ls,
- forall (CF: c = f.(RTL.fn_code))
- (WT: wt_function f env)
- (ANL: analyze f = Some live)
- (ASG: regalloc f live (live0 f live) env = Some assign)
- (AG: agree assign (transfer f pc live!!pc) rs ls)
- (VALIDPC': c!pc' <> None),
- let tc := PTree.map (transf_instr f live assign) c in
- exists ls',
- exec_blocks tge tc sp pc ls m t (Cont pc') ls' m' /\
- agree assign (transfer f pc' live!!pc') rs' ls'.
-
-Definition exec_function_prop
- (f: RTL.fundef) (args: list val) (m: mem)
- (t: trace) (res: val) (m': mem) : Prop :=
- forall ls tf,
- transf_fundef f = Some tf ->
- List.map ls (Conventions.loc_arguments (funsig tf)) = args ->
- exists ls',
- LTL.exec_function tge tf ls m t ls' m' /\
- ls' (R (Conventions.loc_result (funsig tf))) = res.
-
-(** The simulation proof is by structural induction over the RTL evaluation
- derivation. We prove each case of the proof as a separate lemma.
- There is one lemma for each RTL evaluation rule. Each lemma concludes
- one of the [exec_*_prop] predicates, and takes the induction hypotheses
- (if any) as hypotheses also expressed with the [exec_*_prop] predicates.
-*)
+Inductive match_stackframes: list RTL.stackframe -> list LTL.stackframe -> signature -> Prop :=
+ | match_stackframes_nil: forall ty_args,
+ match_stackframes nil nil (mksignature ty_args (Some Tint))
+ | match_stackframes_cons:
+ forall s ts sig res f sp pc rs ls env live assign,
+ match_stackframes s ts (RTL.fn_sig f) ->
+ wt_function f env ->
+ analyze f = Some live ->
+ regalloc f live (live0 f live) env = Some assign ->
+ (forall rv ls1,
+ (forall l, Loc.notin l destroyed_at_call -> loc_acceptable l -> ls1 l = ls l) ->
+ Val.lessdef rv (ls1 (R (loc_result sig))) ->
+ agree assign (transfer f pc live!!pc)
+ (rs#res <- rv)
+ (Locmap.set (assign res) (ls1 (R (loc_result sig))) ls1)) ->
+ match_stackframes
+ (RTL.Stackframe res (RTL.fn_code f) sp pc rs :: s)
+ (LTL.Stackframe (assign res) (transf_fun f live assign) sp ls pc :: ts)
+ sig.
+
+Inductive match_states: RTL.state -> LTL.state -> Prop :=
+ | match_states_intro:
+ forall s f sp pc rs m ts ls tm live assign env
+ (STACKS: match_stackframes s ts (RTL.fn_sig f))
+ (WT: wt_function f env)
+ (ANL: analyze f = Some live)
+ (ASG: regalloc f live (live0 f live) env = Some assign)
+ (AG: agree assign (transfer f pc live!!pc) rs ls)
+ (MMD: Mem.lessdef m tm),
+ match_states (RTL.State s (RTL.fn_code f) sp pc rs m)
+ (LTL.State ts (transf_fun f live assign) sp pc ls tm)
+ | match_states_call:
+ forall s f args m ts tf ls tm,
+ match_stackframes s ts (RTL.funsig f) ->
+ transf_fundef f = OK tf ->
+ Val.lessdef_list args (List.map ls (loc_arguments (funsig tf))) ->
+ Mem.lessdef m tm ->
+ (forall l, Loc.notin l destroyed_at_call -> loc_acceptable l -> ls l = parent_locset ts l) ->
+ match_states (RTL.Callstate s f args m)
+ (LTL.Callstate ts tf ls tm)
+ | match_states_return:
+ forall s v m ts sig ls tm,
+ match_stackframes s ts sig ->
+ Val.lessdef v (ls (R (loc_result sig))) ->
+ Mem.lessdef m tm ->
+ (forall l, Loc.notin l destroyed_at_call -> loc_acceptable l -> ls l = parent_locset ts l) ->
+ match_states (RTL.Returnstate s v m)
+ (LTL.Returnstate ts sig ls tm).
+
+Remark match_stackframes_change:
+ forall s ts sig,
+ match_stackframes s ts sig ->
+ forall sig',
+ sig_res sig' = sig_res sig ->
+ match_stackframes s ts sig'.
+Proof.
+ induction 1; intros.
+ destruct sig'. simpl in H; inv H. constructor.
+ assert (loc_result sig' = loc_result sig).
+ unfold loc_result. rewrite H4; auto.
+ econstructor; eauto.
+ rewrite H5. auto.
+Qed.
+
+(** The simulation proof is by case analysis over the RTL transition
+ taken in the source program. *)
Ltac CleanupHyps :=
match goal with
+ | H: (match_states _ _) |- _ =>
+ inv H; CleanupHyps
| H1: (PTree.get _ _ = Some _),
- H2: (_ = RTL.fn_code _),
- H3: (agree _ (transfer _ _ _) _ _) |- _ =>
- unfold transfer in H3; rewrite <- H2 in H3; rewrite H1 in H3;
- simpl in H3;
- CleanupHyps
+ H2: (agree _ (transfer _ _ _) _ _) |- _ =>
+ unfold transfer in H2; rewrite H1 in H2; simpl in H2; CleanupHyps
+ | _ => idtac
+ end.
+
+Ltac WellTypedHyp :=
+ match goal with
| H1: (PTree.get _ _ = Some _),
- H2: (_ = RTL.fn_code _),
- H3: (wt_function _ _) |- _ =>
- let H := fresh in
+ H2: (wt_function _ _) |- _ =>
let R := fresh "WTI" in (
- generalize (wt_instrs _ _ H3); intro H;
- rewrite <- H2 in H; generalize (H _ _ H1);
- intro R; clear H; clear H3);
- CleanupHyps
+ generalize (wt_instrs _ _ H2 _ _ H1); intro R)
| _ => idtac
end.
-Ltac CleanupGoal :=
+Ltac TranslInstr :=
match goal with
- | H1: (PTree.get _ _ = Some _) |- _ =>
- eapply exec_blocks_one;
- [rewrite PTree.gmap; rewrite H1;
- unfold option_map; unfold transf_instr; reflexivity
- |idtac]
+ | H: (PTree.get _ _ = Some _) |- _ =>
+ simpl; rewrite PTree.gmap; rewrite H; simpl; auto
end.
-Lemma transl_Inop_correct:
- forall (c : PTree.t instruction) (sp: val) (pc : positive)
- (rs : regset) (m : mem) (pc' : RTL.node),
- c ! pc = Some (Inop pc') ->
- exec_instr_prop c sp pc rs m E0 pc' rs m.
+Ltac MatchStates :=
+ match goal with
+ | |- match_states (RTL.State _ _ _ _ _ _) (LTL.State _ _ _ _ _ _) =>
+ eapply match_states_intro; eauto; MatchStates
+ | H: (PTree.get ?pc _ = Some _) |- agree _ _ _ _ =>
+ eapply agree_succ with (n := pc); eauto; MatchStates
+ | H: (PTree.get _ _ = Some _) |- In _ (RTL.successors _ _) =>
+ unfold RTL.successors; rewrite H; auto with coqlib
+ | _ => idtac
+ end.
+
+
+Lemma transl_find_function:
+ forall ros f args lv rs ls alloc,
+ RTL.find_function ge ros rs = Some f ->
+ agree alloc (reg_list_live args (reg_sum_live ros lv)) rs ls ->
+ exists tf,
+ LTL.find_function tge (sum_left_map alloc ros) ls = Some tf /\
+ transf_fundef f = OK tf.
Proof.
- intros; red; intros; CleanupHyps.
- exists ls. split.
- CleanupGoal. apply exec_Bgoto. apply exec_refl.
- assumption.
+ intros; destruct ros; simpl in *.
+ assert (Val.lessdef (rs#r) (ls (alloc r))).
+ eapply agree_eval_reg. eapply agree_reg_list_live; eauto.
+ inv H1. apply functions_translated. auto.
+ exploit Genv.find_funct_inv; eauto. intros [b EQ]. congruence.
+ rewrite symbols_preserved. destruct (Genv.find_symbol ge i).
+ apply function_ptr_translated. auto. discriminate.
Qed.
-Lemma transl_Iop_correct:
- forall (c : PTree.t instruction) (sp: val) (pc : positive)
- (rs : Regmap.t val) (m : mem) (op : operation) (args : list reg)
- (res : reg) (pc' : RTL.node) (v: val),
- c ! pc = Some (Iop op args res pc') ->
- eval_operation ge sp op (rs ## args) = Some v ->
- exec_instr_prop c sp pc rs m E0 pc' (rs # res <- v) m.
+Theorem transl_step_correct:
+ forall s1 t s2, RTL.step ge s1 t s2 ->
+ forall s1', match_states s1 s1' ->
+ exists s2', LTL.step tge s1' t s2' /\ match_states s2 s2'.
Proof.
- intros; red; intros; CleanupHyps.
+ induction 1; intros; CleanupHyps; WellTypedHyp.
+
+ (* Inop *)
+ econstructor; split.
+ eapply exec_Lnop. TranslInstr. MatchStates.
+
+ (* Iop *)
+ generalize (PTree.gmap (transf_instr f live assign) pc (RTL.fn_code f)).
+ rewrite H. simpl.
caseEq (Regset.mem res live!!pc); intro LV;
rewrite LV in AG.
generalize (Regset.mem_2 _ _ LV). intro LV'.
- assert (LL: (List.length (List.map assign args) <= 3)%nat).
- rewrite list_length_map.
- inversion WTI. simpl; omega. simpl; omega.
- eapply length_op_args. eauto.
- assert (DISJ: Loc.disjoint (List.map assign args) temporaries).
- eapply regalloc_disj_temporaries; eauto.
- assert (eval_operation tge sp op (map ls (map assign args)) = Some v).
- replace (map ls (map assign args)) with rs##args.
- rewrite (eval_operation_preserved symbols_preserved). assumption.
- symmetry. eapply agree_eval_regs; eauto.
- generalize (add_op_correct tge sp op
- (List.map assign args) (assign res)
- pc' ls m v LL DISJ H1).
- intros [ls' [EX [RES OTHER]]].
- exists ls'. split.
- CleanupGoal. rewrite LV. exact EX.
- rewrite CF in H.
generalize (regalloc_correct_1 f env live _ _ _ _ ASG H).
- unfold correct_alloc_instr.
+ unfold correct_alloc_instr, is_redundant_move.
caseEq (is_move_operation op args).
(* Special case for moves *)
intros arg IMO CORR.
generalize (is_move_operation_correct _ _ IMO).
intros [EQ1 EQ2]. subst op; subst args.
- injection H0; intro. rewrite <- H2.
- apply agree_move_live with f env live ls; auto.
- rewrite RES. rewrite <- H2. symmetry. eapply agree_eval_reg.
- simpl in AG. eexact AG.
+ injection H0; intro.
+ destruct (Loc.eq (assign arg) (assign res)); intro CODE.
+ (* sub-case: redundant move *)
+ econstructor; split. eapply exec_Lnop; eauto.
+ MatchStates.
+ rewrite <- H1. eapply agree_redundant_move_live; eauto.
+ (* sub-case: non-redundant move *)
+ econstructor; split. eapply exec_Lop; eauto. simpl. eauto.
+ MatchStates.
+ rewrite <- H1. eapply agree_move_live; eauto.
(* Not a move *)
- intros INMO CORR.
- apply agree_assign_live with f env live ls; auto.
+ intros INMO CORR CODE.
+ assert (exists v1,
+ eval_operation tge sp op (map ls (map assign args)) tm = Some v1
+ /\ Val.lessdef v v1).
+ apply eval_operation_lessdef with m (rs##args); auto.
+ eapply agree_eval_regs; eauto.
+ rewrite (eval_operation_preserved symbols_preserved). assumption.
+ destruct H1 as [v1 [EV VMD]].
+ econstructor; split. eapply exec_Lop; eauto.
+ MatchStates.
+ apply agree_assign_live with f env live; auto.
eapply agree_reg_list_live; eauto.
(* Result is not live, instruction turned into a nop *)
- exists ls. split.
- CleanupGoal. rewrite LV.
- apply exec_Bgoto; apply exec_refl.
- apply agree_assign_dead; auto.
+ intro CODE. econstructor; split. eapply exec_Lnop; eauto.
+ MatchStates. apply agree_assign_dead; auto.
red; intro. exploit Regset.mem_1; eauto. congruence.
-Qed.
-Lemma transl_Iload_correct:
- forall (c : PTree.t instruction) (sp: val) (pc : positive)
- (rs : Regmap.t val) (m : mem) (chunk : memory_chunk)
- (addr : addressing) (args : list reg) (dst : reg) (pc' : RTL.node)
- (a v : val),
- c ! pc = Some (Iload chunk addr args dst pc') ->
- eval_addressing ge sp addr rs ## args = Some a ->
- loadv chunk m a = Some v ->
- exec_instr_prop c sp pc rs m E0 pc' rs # dst <- v m.
-Proof.
- intros; red; intros; CleanupHyps.
+ (* Iload *)
caseEq (Regset.mem dst live!!pc); intro LV;
rewrite LV in AG.
(* dst is live *)
exploit Regset.mem_2; eauto. intro LV'.
- assert (LL: (List.length (List.map assign args) <= 2)%nat).
- rewrite list_length_map.
- inversion WTI.
- eapply length_addr_args. eauto.
- assert (DISJ: Loc.disjoint (List.map assign args) temporaries).
- eapply regalloc_disj_temporaries; eauto.
- assert (EADDR:
- eval_addressing tge sp addr (map ls (map assign args)) = Some a).
- rewrite <- H0.
- replace (rs##args) with (map ls (map assign args)).
- apply eval_addressing_preserved. exact symbols_preserved.
+ assert (exists a',
+ eval_addressing tge sp addr (map ls (map assign args)) = Some a'
+ /\ Val.lessdef a a').
+ apply eval_addressing_lessdef with (rs##args).
eapply agree_eval_regs; eauto.
- generalize (add_load_correct tge sp chunk addr
- (List.map assign args) (assign dst)
- pc' ls m _ _ LL DISJ EADDR H1).
- intros [ls' [EX [RES OTHER]]].
- exists ls'. split. CleanupGoal. rewrite LV. exact EX.
- rewrite CF in H.
+ rewrite <- H0. apply eval_addressing_preserved. exact symbols_preserved.
+ destruct H2 as [a' [EVAL VMD]].
+ exploit Mem.loadv_lessdef; eauto.
+ intros [v' [LOADV VMD2]].
+ econstructor; split.
+ eapply exec_Lload; eauto. TranslInstr. rewrite LV; auto.
generalize (regalloc_correct_1 f env live _ _ _ _ ASG H).
unfold correct_alloc_instr. intro CORR.
+ MatchStates.
eapply agree_assign_live; eauto.
eapply agree_reg_list_live; eauto.
(* dst is dead *)
- exists ls. split.
- CleanupGoal. rewrite LV.
- apply exec_Bgoto; apply exec_refl.
- apply agree_assign_dead; auto.
+ econstructor; split.
+ eapply exec_Lnop. TranslInstr. rewrite LV; auto.
+ MatchStates. apply agree_assign_dead; auto.
red; intro; exploit Regset.mem_1; eauto. congruence.
-Qed.
-Lemma transl_Istore_correct:
- forall (c : PTree.t instruction) (sp: val) (pc : positive)
- (rs : Regmap.t val) (m : mem) (chunk : memory_chunk)
- (addr : addressing) (args : list reg) (src : reg) (pc' : RTL.node)
- (a : val) (m' : mem),
- c ! pc = Some (Istore chunk addr args src pc') ->
- eval_addressing ge sp addr rs ## args = Some a ->
- storev chunk m a rs # src = Some m' ->
- exec_instr_prop c sp pc rs m E0 pc' rs m'.
-Proof.
- intros; red; intros; CleanupHyps.
- assert (LL: (List.length (List.map assign args) <= 2)%nat).
- rewrite list_length_map.
- inversion WTI.
- eapply length_addr_args. eauto.
- assert (DISJ: Loc.disjoint (List.map assign args) temporaries).
- eapply regalloc_disj_temporaries; eauto.
- assert (SRC: Loc.notin (assign src) temporaries).
- eapply regalloc_not_temporary; eauto.
- assert (EADDR:
- eval_addressing tge sp addr (map ls (map assign args)) = Some a).
- rewrite <- H0.
- replace (rs##args) with (map ls (map assign args)).
- apply eval_addressing_preserved. exact symbols_preserved.
+ (* Istore *)
+ assert (exists a',
+ eval_addressing tge sp addr (map ls (map assign args)) = Some a'
+ /\ Val.lessdef a a').
+ apply eval_addressing_lessdef with (rs##args).
eapply agree_eval_regs; eauto.
- assert (ESRC: ls (assign src) = rs#src).
+ rewrite <- H0. apply eval_addressing_preserved. exact symbols_preserved.
+ destruct H2 as [a' [EVAL VMD]].
+ assert (ESRC: Val.lessdef rs#src (ls (assign src))).
eapply agree_eval_reg. eapply agree_reg_list_live. eauto.
- rewrite <- ESRC in H1.
- generalize (add_store_correct tge sp chunk addr
- (List.map assign args) (assign src)
- pc' ls m m' a LL DISJ SRC EADDR H1).
- intros [ls' [EX RES]].
- exists ls'. split. CleanupGoal. exact EX.
- rewrite CF in H.
- generalize (regalloc_correct_1 f env live _ _ _ _ ASG H).
- unfold correct_alloc_instr. intro CORR.
- eapply agree_exten. eauto.
- eapply agree_reg_live. eapply agree_reg_list_live. eauto.
- assumption.
-Qed.
-
-Lemma transl_Icall_correct:
- forall (c : PTree.t instruction) (sp: val) (pc : positive)
- (rs : regset) (m : mem) (sig : signature) (ros : reg + ident)
- (args : list reg) (res : reg) (pc' : RTL.node)
- (f : RTL.fundef) (vres : val) (m' : mem) (t: trace),
- c ! pc = Some (Icall sig ros args res pc') ->
- RTL.find_function ge ros rs = Some f ->
- RTL.funsig f = sig ->
- RTL.exec_function ge f (rs##args) m t vres m' ->
- exec_function_prop f (rs##args) m t vres m' ->
- exec_instr_prop c sp pc rs m t pc' (rs#res <- vres) m'.
-Proof.
- intros; red; intros; CleanupHyps.
- set (los := sum_left_map assign ros).
- assert (FIND: exists tf,
- find_function2 tge los ls = Some tf /\
- transf_fundef f = Some tf).
- unfold los. destruct ros; simpl; simpl in H0.
- apply functions_translated.
- replace (ls (assign r)) with rs#r. assumption.
- simpl in AG. symmetry; eapply agree_eval_reg.
- eapply agree_reg_list_live; eauto.
- rewrite symbols_preserved. destruct (Genv.find_symbol ge i).
- apply function_ptr_translated. auto.
- discriminate.
- elim FIND; intros tf [AFIND TRF]; clear FIND.
- assert (ASIG: sig = funsig tf).
- rewrite (sig_function_translated _ _ TRF). auto.
- generalize (fun ls => H3 ls tf TRF); intro AEXECF.
- assert (AVARGS: List.map ls (List.map assign args) = rs##args).
- eapply agree_eval_regs; eauto.
- assert (ALARGS: List.length (List.map assign args) =
- List.length sig.(sig_args)).
- inversion WTI. rewrite <- H10.
- repeat rewrite list_length_map. auto.
- assert (AACCEPT: locs_acceptable (List.map assign args)).
- eapply regsalloc_acceptable; eauto.
- rewrite CF in H.
- generalize (regalloc_correct_1 f0 env live _ _ _ _ ASG H).
- unfold correct_alloc_instr. intros [CORR1 CORR2].
- assert (ARES: loc_acceptable (assign res)).
- eapply regalloc_acceptable; eauto.
- generalize (add_call_correct tge sp tf _ _ _ _ _ _ _ _ _ pc' _
- AEXECF AFIND ASIG AVARGS ALARGS
- AACCEPT ARES).
- intros [ls' [EX [RES OTHER]]].
- exists ls'.
- split. rewrite CF. CleanupGoal. exact EX.
- simpl. eapply agree_call; eauto.
-Qed.
-
-Lemma transl_Ialloc_correct:
- forall (c : PTree.t instruction) (sp: val) (pc : positive)
- (rs : Regmap.t val) (m : mem) (pc': RTL.node) (arg res: reg)
- (sz: int) (m': mem) (b: Values.block),
- c ! pc = Some (Ialloc arg res pc') ->
- rs#arg = Vint sz ->
- Mem.alloc m 0 (Int.signed sz) = (m', b) ->
- exec_instr_prop c sp pc rs m E0 pc' (rs # res <- (Vptr b Int.zero)) m'.
-Proof.
- intros; red; intros; CleanupHyps.
- assert (SZ: ls (assign arg) = Vint sz).
+ assert (exists tm', storev chunk tm a' (ls (assign src)) = Some tm'
+ /\ Mem.lessdef m' tm').
+ eapply Mem.storev_lessdef; eauto.
+ destruct H2 as [m1' [STORE MMD']].
+ econstructor; split.
+ eapply exec_Lstore; eauto. TranslInstr.
+ MatchStates. eapply agree_reg_live. eapply agree_reg_list_live. eauto.
+
+ (* Icall *)
+ exploit transl_find_function; eauto. intros [tf [TFIND TF]].
+ generalize (regalloc_correct_1 f0 env live _ _ _ _ ASG H).
unfold correct_alloc_instr. intros [CORR1 CORR2].
+ exploit (parmov_spec ls (map assign args)
+ (loc_arguments (RTL.funsig f))).
+ apply loc_arguments_norepet.
+ rewrite loc_arguments_length. inv WTI.
+ rewrite <- H7. repeat rewrite list_length_map. auto.
+ intros [PM1 PM2].
+ econstructor; split.
+ eapply exec_Lcall; eauto. TranslInstr.
+ rewrite (sig_function_translated _ _ TF). eauto.
+ rewrite (sig_function_translated _ _ TF).
+ econstructor; eauto.
+ econstructor; eauto.
+ intros. eapply agree_succ with (n := pc); eauto.
+ unfold RTL.successors; rewrite H; auto with coqlib.
+ eapply agree_call with (ls := ls); eauto.
+ rewrite Locmap.gss. auto.
+ intros. rewrite Locmap.gso. rewrite H1; auto. apply PM2; auto.
+ eapply arguments_not_preserved; eauto. apply Loc.diff_sym; auto.
+ rewrite (sig_function_translated _ _ TF).
+ change Regset.elt with reg in PM1.
+ rewrite PM1. eapply agree_eval_regs; eauto.
+
+ (* Itailcall *)
+ exploit transl_find_function; eauto. intros [tf [TFIND TF]].
+ exploit (parmov_spec ls (map assign args)
+ (loc_arguments (RTL.funsig f))).
+ apply loc_arguments_norepet.
+ rewrite loc_arguments_length. inv WTI.
+ rewrite <- H6. repeat rewrite list_length_map. auto.
+ intros [PM1 PM2].
+ econstructor; split.
+ eapply exec_Ltailcall; eauto. TranslInstr.
+ rewrite (sig_function_translated _ _ TF). eauto.
+ rewrite (sig_function_translated _ _ TF).
+ econstructor; eauto.
+ apply match_stackframes_change with (RTL.fn_sig f0); auto.
+ inv WTI. auto.
+ rewrite (sig_function_translated _ _ TF).
+ rewrite return_regs_arguments.
+ change Regset.elt with reg in PM1.
+ rewrite PM1. eapply agree_eval_regs; eauto.
+ inv WTI; auto.
+ apply free_lessdef; auto.
+ intros. rewrite return_regs_not_destroyed; auto.
+
+ (* Ialloc *)
+ assert (Val.lessdef (Vint sz) (ls (assign arg))).
rewrite <- H0. eapply agree_eval_reg. eauto.
- generalize (add_alloc_correct tge sp (assign arg) (assign res)
- pc' ls m m' sz b SZ H1).
- intros [ls' [EX [RES OTHER]]].
- exists ls'.
- split. CleanupGoal. exact EX.
- rewrite CF in H.
+ inversion H2. subst v.
+ pose (ls1 := Locmap.set (R loc_alloc_argument) (ls (assign arg)) ls).
+ pose (ls2 := Locmap.set (R loc_alloc_result) (Vptr b Int.zero) ls1).
+ pose (ls3 := Locmap.set (assign res) (ls2 (R loc_alloc_result)) ls2).
+ caseEq (alloc tm 0 (Int.signed sz)). intros tm' b1 ALLOC1.
+ exploit Mem.alloc_lessdef; eauto. intros [EQ MMD1]. subst b1.
+ exists (State ts (transf_fun f live assign) sp pc' ls3 tm'); split.
+ unfold ls3, ls2, ls1. eapply exec_Lalloc; eauto. TranslInstr.
generalize (regalloc_correct_1 f env live _ _ _ _ ASG H).
unfold correct_alloc_instr. intros [CORR1 CORR2].
- eapply agree_call with (args := arg :: nil) (ros := inr reg 1%positive) (ls := ls) (ls' := ls'); eauto.
- intros. apply OTHER.
- eapply Loc.in_notin_diff; eauto.
- unfold loc_alloc_argument, destroyed_at_call; simpl; tauto.
- eapply Loc.in_notin_diff; eauto.
+ MatchStates.
+ eapply agree_call with (args := arg :: nil) (ros := inr reg 1%positive) (ls := ls); eauto.
+ unfold ls3; rewrite Locmap.gss.
+ unfold ls2; rewrite Locmap.gss. auto.
+ intros. unfold ls3; rewrite Locmap.gso.
+ unfold ls2; rewrite Locmap.gso.
+ unfold ls1; apply Locmap.gso.
+ apply Loc.diff_sym. eapply Loc.in_notin_diff; eauto.
unfold loc_alloc_argument, destroyed_at_call; simpl; tauto.
- auto.
-Qed.
-
-Lemma transl_Icond_true_correct:
- forall (c : PTree.t instruction) (sp: val) (pc : positive)
- (rs : Regmap.t val) (m : mem) (cond : condition) (args : list reg)
- (ifso ifnot : RTL.node),
- c ! pc = Some (Icond cond args ifso ifnot) ->
- eval_condition cond rs ## args = Some true ->
- exec_instr_prop c sp pc rs m E0 ifso rs m.
-Proof.
- intros; red; intros; CleanupHyps.
- assert (LL: (List.length (map assign args) <= 3)%nat).
- rewrite list_length_map. inversion WTI.
- eapply length_cond_args. eauto.
- assert (DISJ: Loc.disjoint (map assign args) temporaries).
- eapply regalloc_disj_temporaries; eauto.
- assert (COND: eval_condition cond (map ls (map assign args)) = Some true).
- replace (map ls (map assign args)) with rs##args. assumption.
- symmetry. eapply agree_eval_regs; eauto.
- generalize (add_cond_correct tge sp _ _ _ ifnot _ m _ _
- LL DISJ COND (refl_equal ifso)).
- intros [ls' [EX OTHER]].
- exists ls'. split.
- CleanupGoal. assumption.
- eapply agree_exten. eauto. eapply agree_reg_list_live. eauto.
- assumption.
-Qed.
-
-Lemma transl_Icond_false_correct:
- forall (c : PTree.t instruction) (sp: val) (pc : positive)
- (rs : Regmap.t val) (m : mem) (cond : condition) (args : list reg)
- (ifso ifnot : RTL.node),
- c ! pc = Some (Icond cond args ifso ifnot) ->
- eval_condition cond rs ## args = Some false ->
- exec_instr_prop c sp pc rs m E0 ifnot rs m.
-Proof.
- intros; red; intros; CleanupHyps.
- assert (LL: (List.length (map assign args) <= 3)%nat).
- rewrite list_length_map. inversion WTI.
- eapply length_cond_args. eauto.
- assert (DISJ: Loc.disjoint (map assign args) temporaries).
- eapply regalloc_disj_temporaries; eauto.
- assert (COND: eval_condition cond (map ls (map assign args)) = Some false).
- replace (map ls (map assign args)) with rs##args. assumption.
- symmetry. eapply agree_eval_regs; eauto.
- generalize (add_cond_correct tge sp _ _ ifso _ _ m _ _
- LL DISJ COND (refl_equal ifnot)).
- intros [ls' [EX OTHER]].
- exists ls'. split.
- CleanupGoal. assumption.
- eapply agree_exten. eauto. eapply agree_reg_list_live. eauto.
- assumption.
-Qed.
-
-Lemma transl_refl_correct:
- forall (c : RTL.code) (sp: val) (pc : RTL.node) (rs : regset)
- (m : mem), exec_instrs_prop c sp pc rs m E0 pc rs m.
-Proof.
- intros; red; intros.
- exists ls. split. apply exec_blocks_refl. assumption.
-Qed.
-
-Lemma transl_one_correct:
- forall (c : RTL.code) (sp: val) (pc : RTL.node) (rs : regset)
- (m : mem) (t: trace) (pc' : RTL.node) (rs' : regset) (m' : mem),
- RTL.exec_instr ge c sp pc rs m t pc' rs' m' ->
- exec_instr_prop c sp pc rs m t pc' rs' m' ->
- exec_instrs_prop c sp pc rs m t pc' rs' m'.
-Proof.
- intros; red; intros.
- generalize (H0 f env live assign ls CF WT ASG AG).
- intros [ls' [EX AG']].
- exists ls'. split.
- exact EX.
- apply agree_increasing with live!!pc.
- apply analyze_correct. auto.
- rewrite <- CF. eapply exec_instr_present; eauto.
- rewrite <- CF. auto.
- eapply RTL.successors_correct.
- rewrite <- CF. eexact H. exact AG'.
-Qed.
-
-Lemma transl_trans_correct:
- forall (c : RTL.code) (sp: val) (pc1 : RTL.node) (rs1 : regset)
- (m1 : mem) (t1: trace) (pc2 : RTL.node) (rs2 : regset) (m2 : mem)
- (t2: trace) (pc3 : RTL.node) (rs3 : regset) (m3 : mem) (t3: trace),
- RTL.exec_instrs ge c sp pc1 rs1 m1 t1 pc2 rs2 m2 ->
- exec_instrs_prop c sp pc1 rs1 m1 t1 pc2 rs2 m2 ->
- RTL.exec_instrs ge c sp pc2 rs2 m2 t2 pc3 rs3 m3 ->
- exec_instrs_prop c sp pc2 rs2 m2 t2 pc3 rs3 m3 ->
- t3 = t1 ** t2 ->
- exec_instrs_prop c sp pc1 rs1 m1 t3 pc3 rs3 m3.
-Proof.
- intros; red; intros.
- assert (VALIDPC2: c!pc2 <> None).
- eapply exec_instrs_present; eauto.
- generalize (H0 f env live assign ls CF WT ANL ASG AG VALIDPC2).
- intros [ls1 [EX1 AG1]].
- generalize (H2 f env live assign ls1 CF WT ANL ASG AG1 VALIDPC').
- intros [ls2 [EX2 AG2]].
- exists ls2. split.
- eapply exec_blocks_trans. eexact EX1. eexact EX2. auto.
- exact AG2.
-Qed.
-
-Remark regset_mem_reg_list_dead:
- forall rl r live,
- Regset.In r (reg_list_dead rl live) ->
- ~(In r rl) /\ Regset.In r live.
-Proof.
- induction rl; simpl; intros.
- tauto.
- elim (IHrl r (reg_dead a live) H). intros.
- assert (a <> r). red; intro; subst r.
- exploit Regset.remove_1; eauto.
- intuition. eapply Regset.remove_3; eauto.
-Qed.
-
-Lemma transf_entrypoint_correct:
- forall f env live assign c ls args sp m,
- wt_function f env ->
- regalloc f live (live0 f live) env = Some assign ->
- c!(RTL.fn_nextpc f) = None ->
- List.map ls (loc_parameters (RTL.fn_sig f)) = args ->
- (forall ofs ty, ls (S (Local ofs ty)) = Vundef) ->
- let tc := transf_entrypoint f live assign c in
- exists ls',
- exec_blocks tge tc sp (RTL.fn_nextpc f) ls m E0
- (Cont (RTL.fn_entrypoint f)) ls' m /\
- agree assign (transfer f (RTL.fn_entrypoint f) live!!(RTL.fn_entrypoint f))
- (init_regs args (RTL.fn_params f)) ls'.
-Proof.
- intros until m.
- unfold transf_entrypoint.
- set (oldentry := RTL.fn_entrypoint f).
- set (newentry := RTL.fn_nextpc f).
- set (params := RTL.fn_params f).
- set (undefs := Regset.elements (reg_list_dead params (transfer f oldentry live!!oldentry))).
- intros.
-
- assert (A1: List.length (List.map assign params) =
- List.length (RTL.fn_sig f).(sig_args)).
- rewrite <- (wt_params _ _ H).
- repeat (rewrite list_length_map). auto.
- assert (A2: Loc.norepet (List.map assign (RTL.fn_params f))).
- eapply regalloc_norepet_norepet; eauto.
- eapply regalloc_correct_2; eauto.
- eapply wt_norepet; eauto.
- assert (A3: locs_acceptable (List.map assign (RTL.fn_params f))).
- eapply regsalloc_acceptable; eauto.
- assert (A4: Loc.disjoint
- (List.map assign (RTL.fn_params f))
- (List.map assign undefs)).
- red. intros ap au INAP INAU.
- generalize (list_in_map_inv _ _ _ INAP).
- intros [p [AP INP]]. clear INAP; subst ap.
- generalize (list_in_map_inv _ _ _ INAU).
- intros [u [AU INU]]. clear INAU; subst au.
- assert (INU': InA Regset.E.eq u undefs).
- rewrite InA_alt. exists u; intuition.
- generalize (Regset.elements_2 _ _ INU'). intro.
- generalize (regset_mem_reg_list_dead _ _ _ H4).
- intros [A B].
- eapply regalloc_noteq_diff; eauto.
- eapply regalloc_correct_3; eauto.
- red; intro; subst u. elim (A INP).
- assert (A5: forall l, In l (List.map assign undefs) -> loc_acceptable l).
- intros.
- generalize (list_in_map_inv _ _ _ H4).
- intros [r [AR INR]]. clear H4; subst l.
- eapply regalloc_acceptable; eauto.
- generalize (add_entry_correct
- tge sp (RTL.fn_sig f)
- (List.map assign (RTL.fn_params f))
- (List.map assign undefs)
- oldentry ls m A1 A2 A3 A4 A5 H3).
- intros [ls1 [EX1 [PARAMS1 UNDEFS1]]].
- exists ls1.
- split. eapply exec_blocks_one.
- rewrite PTree.gss. reflexivity.
- assumption.
- change (transfer f oldentry live!!oldentry)
- with (live0 f live).
- unfold params; eapply agree_parameters; eauto.
- change Regset.elt with reg in PARAMS1.
- rewrite PARAMS1. assumption.
- fold oldentry; fold params. intros.
- apply UNDEFS1. apply in_map.
- unfold undefs.
- change (transfer f oldentry live!!oldentry)
- with (live0 f live).
- exploit Regset.elements_1; eauto.
- rewrite InA_alt. intros [r' [C D]]. hnf in C. subst r'. auto.
-Qed.
-
-Lemma transl_function_correct:
- forall (f : RTL.function) (m m1 : mem) (stk : Values.block)
- (args : list val) (t: trace) (pc : RTL.node) (rs : regset) (m2 : mem)
- (or : option reg) (vres : val),
- alloc m 0 (RTL.fn_stacksize f) = (m1, stk) ->
- RTL.exec_instrs ge (RTL.fn_code f) (Vptr stk Int.zero)
- (RTL.fn_entrypoint f) (init_regs args (fn_params f)) m1 t pc rs m2 ->
- exec_instrs_prop (RTL.fn_code f) (Vptr stk Int.zero)
- (RTL.fn_entrypoint f) (init_regs args (fn_params f)) m1 t pc rs m2 ->
- (RTL.fn_code f) ! pc = Some (Ireturn or) ->
- vres = regmap_optget or Vundef rs ->
- exec_function_prop (Internal f) args m t vres (free m2 stk).
-Proof.
- intros; red; intros until tf.
- unfold transf_fundef, transf_partial_fundef, transf_function.
- caseEq (type_function f).
- intros env TRF.
- caseEq (analyze f).
- intros live ANL.
- change (transfer f (RTL.fn_entrypoint f) live!!(RTL.fn_entrypoint f))
- with (live0 f live).
- caseEq (regalloc f live (live0 f live) env).
- intros alloc ASG.
- set (tc1 := PTree.map (transf_instr f live alloc) (RTL.fn_code f)).
- set (tc2 := transf_entrypoint f live alloc tc1).
- intro EQ; injection EQ; intro TF; clear EQ. intro VARGS.
- generalize (type_function_correct _ _ TRF); intro WTF.
- assert (NEWINSTR: tc1!(RTL.fn_nextpc f) = None).
- unfold tc1; rewrite PTree.gmap. unfold option_map.
- elim (RTL.fn_code_wf f (fn_nextpc f)); intro.
- elim (Plt_ne _ _ H4). auto.
- rewrite H4. auto.
- pose (ls1 := call_regs ls).
- assert (VARGS1: List.map ls1 (loc_parameters (RTL.fn_sig f)) = args).
- replace (RTL.fn_sig f) with (funsig tf).
- rewrite <- VARGS. unfold loc_parameters.
- rewrite list_map_compose. apply list_map_exten.
- intros. symmetry. unfold ls1. eapply call_regs_param_of_arg; eauto.
- rewrite <- TF; reflexivity.
- assert (VUNDEFS: forall (ofs : Z) (ty : typ), ls1 (S (Local ofs ty)) = Vundef).
- intros. reflexivity.
- generalize (transf_entrypoint_correct f env live alloc
- tc1 ls1 args (Vptr stk Int.zero) m1
- WTF ASG NEWINSTR VARGS1 VUNDEFS).
- fold tc2. intros [ls2 [EX2 AGREE2]].
- assert (VALIDPC: f.(RTL.fn_code)!pc <> None). congruence.
- generalize (H1 f env live alloc ls2
- (refl_equal _) WTF ANL ASG AGREE2 VALIDPC).
- fold tc1. intros [ls3 [EX3 AGREE3]].
- generalize (add_return_correct tge (Vptr stk Int.zero) (RTL.fn_sig f)
- (option_map alloc or) ls3 m2).
- intros [ls4 [EX4 RES4]].
- exists ls4.
- (* Execution *)
- split. rewrite <- TF; apply exec_funct_internal with m1; simpl.
- assumption.
- fold ls1.
- eapply exec_blocks_trans. eexact EX2.
- apply exec_blocks_extends with tc1.
- intro p. unfold tc2. unfold transf_entrypoint.
- case (peq p (fn_nextpc f)); intro.
- subst p. right. unfold tc1; rewrite PTree.gmap.
- elim (RTL.fn_code_wf f (fn_nextpc f)); intro.
- elim (Plt_ne _ _ H4); auto. rewrite H4; reflexivity.
- left; apply PTree.gso; auto.
- eapply exec_blocks_trans. eexact EX3.
- eapply exec_blocks_one.
- unfold tc1. rewrite PTree.gmap. rewrite H2. simpl. reflexivity.
- eexact EX4. reflexivity. traceEq.
- destruct or.
- simpl in RES4. simpl in H3.
- rewrite H3. rewrite <- TF; simpl. rewrite RES4.
- eapply agree_eval_reg; eauto.
- unfold transfer in AGREE3; rewrite H2 in AGREE3.
- unfold reg_option_live in AGREE3. eexact AGREE3.
- simpl in RES4. simpl in H3.
- rewrite <- TF; simpl. congruence.
- intros; discriminate.
- intros; discriminate.
- intros; discriminate.
-Qed.
+ apply Loc.diff_sym. eapply Loc.in_notin_diff; eauto.
+ unfold loc_alloc_result, destroyed_at_call; simpl; tauto.
+ apply Loc.diff_sym; auto.
-Lemma transl_external_function_correct:
- forall (ef : external_function) (args : list val) (m : mem)
- (t: trace) (res: val),
- event_match ef args t res ->
- exec_function_prop (External ef) args m t res m.
-Proof.
- intros; red; intros.
- simpl in H0.
- simplify_eq H0; intro.
- exists (Locmap.set (R (loc_result (funsig tf))) res ls); split.
- subst tf. eapply exec_funct_external; eauto.
- apply Locmap.gss.
+ (* Icond, true *)
+ assert (COND: eval_condition cond (map ls (map assign args)) tm = Some true).
+ eapply eval_condition_lessdef; eauto.
+ eapply agree_eval_regs; eauto.
+ econstructor; split.
+ eapply exec_Lcond_true; eauto. TranslInstr.
+ MatchStates. eapply agree_reg_list_live. eauto.
+ (* Icond, false *)
+ assert (COND: eval_condition cond (map ls (map assign args)) tm = Some false).
+ eapply eval_condition_lessdef; eauto.
+ eapply agree_eval_regs; eauto.
+ econstructor; split.
+ eapply exec_Lcond_false; eauto. TranslInstr.
+ MatchStates. eapply agree_reg_list_live. eauto.
+
+ (* Ireturn *)
+ econstructor; split.
+ eapply exec_Lreturn; eauto. TranslInstr; eauto.
+ econstructor; eauto.
+ rewrite return_regs_result.
+ inv WTI. destruct or; simpl in *.
+ rewrite Locmap.gss. eapply agree_eval_reg; eauto.
+ constructor.
+ apply free_lessdef; auto.
+ intros. apply return_regs_not_destroyed; auto.
+
+ (* internal function *)
+ generalize H6. simpl. unfold transf_function.
+ caseEq (type_function f); simpl; try congruence. intros env TYP.
+ assert (WTF: wt_function f env). apply type_function_correct; auto.
+ caseEq (analyze f); simpl; try congruence. intros live ANL.
+ caseEq (regalloc f live (live0 f live) env); simpl; try congruence.
+ intros alloc ALLOC EQ. inv EQ. simpl in *.
+ caseEq (Mem.alloc tm 0 (RTL.fn_stacksize f)). intros tm' stk' MEMALLOC.
+ exploit alloc_lessdef; eauto. intros [EQ LDM]. subst stk'.
+ econstructor; split.
+ eapply exec_function_internal; simpl; eauto.
+ simpl. econstructor; eauto.
+ apply agree_init_regs. intros; eapply regalloc_correct_3; eauto.
+ inv WTF.
+ exploit (parmov_spec (call_regs ls)
+ (loc_parameters (RTL.fn_sig f))
+ (map alloc (RTL.fn_params f))).
+ eapply regalloc_norepet_norepet; eauto.
+ eapply regalloc_correct_2; eauto.
+ rewrite loc_parameters_length. symmetry.
+ transitivity (length (map env (RTL.fn_params f))).
+ repeat rewrite list_length_map. auto.
+ rewrite wt_params; auto.
+ intros [PM1 PM2].
+ change Regset.elt with reg in PM1. rewrite PM1.
+ replace (map (call_regs ls) (loc_parameters (RTL.fn_sig f)))
+ with (map ls (loc_arguments (RTL.fn_sig f))).
+ auto.
+ symmetry. unfold loc_parameters. rewrite list_map_compose.
+ apply list_map_exten. intros. symmetry. eapply call_regs_param_of_arg; eauto.
+
+ (* external function *)
+ injection H6; intro EQ; inv EQ.
+ exploit event_match_lessdef; eauto. intros [tres [A B]].
+ econstructor; split.
+ eapply exec_function_external; eauto.
+ eapply match_states_return; eauto.
+ rewrite Locmap.gss. auto.
+ intros. rewrite <- H10; auto. apply Locmap.gso.
+ apply Loc.diff_sym. eapply Loc.in_notin_diff; eauto.
+ apply loc_result_caller_save.
+
+ (* return *)
+ inv H3.
+ econstructor; split.
+ eapply exec_return; eauto.
+ econstructor; eauto.
Qed.
-(** The correctness of the code transformation is obtained by
- structural induction (and case analysis on the last rule used)
- on the RTL evaluation derivation.
- This is a 3-way mutual induction, using [exec_instr_prop],
- [exec_instrs_prop] and [exec_function_prop] as the induction
- hypotheses, and the lemmas above as cases for the induction. *)
-
-Theorem transl_function_correctness:
- forall f args m t res m',
- RTL.exec_function ge f args m t res m' ->
- exec_function_prop f args m t res m'.
-Proof
- (exec_function_ind_3 ge
- exec_instr_prop
- exec_instrs_prop
- exec_function_prop
-
- transl_Inop_correct
- transl_Iop_correct
- transl_Iload_correct
- transl_Istore_correct
- transl_Icall_correct
- transl_Ialloc_correct
- transl_Icond_true_correct
- transl_Icond_false_correct
-
- transl_refl_correct
- transl_one_correct
- transl_trans_correct
-
- transl_function_correct
- transl_external_function_correct).
-
(** The semantic equivalence between the original and transformed programs
follows easily. *)
-Theorem transl_program_correct:
- forall (t: trace) (r: val),
- RTL.exec_program prog t r -> LTL.exec_program tprog t r.
+Lemma transf_initial_states:
+ forall st1, RTL.initial_state prog st1 ->
+ exists st2, LTL.initial_state tprog st2 /\ match_states st1 st2.
Proof.
- intros t r [b [f [m [FIND1 [FIND2 [SIG EXEC]]]]]].
- generalize (function_ptr_translated _ _ FIND2).
- intros [tf [TFIND TRF]].
+ intros. inversion H.
+ exploit function_ptr_translated; eauto. intros [tf [FIND TR]].
assert (SIG2: funsig tf = mksignature nil (Some Tint)).
- rewrite <- SIG. apply sig_function_translated; auto.
- assert (VPARAMS: map (Locmap.init Vundef) (loc_arguments (funsig tf)) = nil).
- rewrite SIG2. reflexivity.
- generalize (transl_function_correctness _ _ _ _ _ _ EXEC
- (Locmap.init Vundef) tf TRF VPARAMS).
- intros [ls' [TEXEC RES]].
- red. exists b; exists tf; exists ls'; exists m.
- split. rewrite symbols_preserved.
- rewrite (transform_partial_program_main _ _ TRANSF).
- assumption.
- split. assumption.
- split. assumption.
- split. replace (Genv.init_mem tprog) with (Genv.init_mem prog).
- assumption. symmetry.
- exact (Genv.init_mem_transf_partial _ _ TRANSF).
- assumption.
+ rewrite <- H2. apply sig_function_translated; auto.
+ assert (VPARAMS: Val.lessdef_list nil (map (Locmap.init Vundef) (loc_arguments (funsig tf)))).
+ rewrite SIG2. simpl. constructor.
+ assert (GENV: (Genv.init_mem tprog) = (Genv.init_mem prog)).
+ exact (Genv.init_mem_transf_partial _ _ TRANSF).
+ assert (MMD: Mem.lessdef (Genv.init_mem prog) (Genv.init_mem tprog)).
+ rewrite GENV. apply Mem.lessdef_refl.
+ exists (LTL.Callstate nil tf (Locmap.init Vundef) (Genv.init_mem tprog)); split.
+ econstructor; eauto.
+ rewrite symbols_preserved.
+ rewrite (transform_partial_program_main _ _ TRANSF). auto.
+ constructor; auto. rewrite H2; constructor.
+Qed.
+
+Lemma transf_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 -> RTL.final_state st1 r -> LTL.final_state st2 r.
+Proof.
+ intros. inv H0. inv H. inv H3. econstructor.
+ inv H4. auto.
+Qed.
+
+Theorem transf_program_correct:
+ forall (beh: program_behavior),
+ RTL.exec_program prog beh -> LTL.exec_program tprog beh.
+Proof.
+ unfold RTL.exec_program, LTL.exec_program; intros.
+ eapply simulation_step_preservation; eauto.
+ eexact transf_initial_states.
+ eexact transf_final_states.
+ exact transl_step_correct.
Qed.
End PRESERVATION.
diff --git a/backend/Alloctyping.v b/backend/Alloctyping.v
index 4c4c4f762dc2b73a4cf156aa45dbd3b54771b594..c0abf0d6d3319f04926ada588f450f6954c766b1 100644
--- a/backend/Alloctyping.v
+++ b/backend/Alloctyping.v
@@ -2,6 +2,7 @@
Require Import Coqlib.
Require Import Maps.
+Require Import Errors.
Require Import AST.
Require Import Op.
Require Import Registers.
@@ -15,7 +16,6 @@ Require Import Allocproof.
Require Import RTLtyping.
Require Import LTLtyping.
Require Import Conventions.
-Require Import Parallelmove.
(** This file proves that register allocation (the translation from
RTL to LTL defined in file [Allocation]) preserves typing:
@@ -30,9 +30,10 @@ Variable live: PMap.t Regset.t.
Variable alloc: reg -> loc.
Variable tf: LTL.function.
-Hypothesis TYPE_RTL: type_function f = Some env.
+Hypothesis TYPE_RTL: type_function f = OK env.
+Hypothesis LIVE: analyze f = Some live.
Hypothesis ALLOC: regalloc f live (live0 f live) env = Some alloc.
-Hypothesis TRANSL: transf_function f = Some tf.
+Hypothesis TRANSL: transf_function f = OK tf.
Lemma wt_rtl_function: RTLtyping.wt_function f env.
Proof.
@@ -51,473 +52,90 @@ Proof.
intros. symmetry. apply alloc_type.
Qed.
-(** [loc_read_ok l] states whether location [l] is well-formed in an
- argument context (for reading). *)
-
-Definition loc_read_ok (l: loc) : Prop :=
- match l with R r => True | S s => slot_bounded tf s end.
-
-(** [loc_write_ok l] states whether location [l] is well-formed in a
- result context (for writing). *)
-
-Definition loc_write_ok (l: loc) : Prop :=
- match l with
- | R r => True
- | S (Incoming _ _) => False
- | S s => slot_bounded tf s end.
-
-Definition locs_read_ok (ll: list loc) : Prop :=
- forall l, In l ll -> loc_read_ok l.
-
-Definition locs_write_ok (ll: list loc) : Prop :=
- forall l, In l ll -> loc_write_ok l.
-
-Remark loc_write_ok_read_ok:
- forall l, loc_write_ok l -> loc_read_ok l.
-Proof.
- destruct l; simpl. auto.
- destruct s; tauto.
-Qed.
-Hint Resolve loc_write_ok_read_ok: allocty.
-
-Remark locs_write_ok_read_ok:
- forall ll, locs_write_ok ll -> locs_read_ok ll.
-Proof.
- unfold locs_write_ok, locs_read_ok. auto with allocty.
-Qed.
-Hint Resolve locs_write_ok_read_ok: allocty.
-
-Lemma alloc_write_ok:
- forall r, loc_write_ok (alloc r).
+Lemma alloc_acceptable:
+ forall r, loc_acceptable (alloc r).
Proof.
- intros. generalize (regalloc_acceptable _ _ _ _ _ r ALLOC).
- destruct (alloc r); simpl. auto.
- destruct s; try contradiction. simpl. omega.
+ intros. eapply regalloc_acceptable; eauto.
Qed.
-Hint Resolve alloc_write_ok: allocty.
-Lemma allocs_write_ok:
- forall rl, locs_write_ok (List.map alloc rl).
+Lemma allocs_acceptable:
+ forall rl, locs_acceptable (List.map alloc rl).
Proof.
- intros; red; intros.
- generalize (list_in_map_inv _ _ _ H). intros [r [EQ IN]].
- subst l. auto with allocty.
+ intros. eapply regsalloc_acceptable; eauto.
Qed.
-Hint Resolve allocs_write_ok: allocty.
-
-(** * Typing LTL constructors *)
-
-(** We show that the LTL constructor functions defined in [Allocation]
- generate well-typed LTL basic blocks, given sufficient typing
- and well-formedness hypotheses over the locations involved. *)
-Lemma wt_add_reload:
- forall src dst k,
- loc_read_ok src ->
- Loc.type src = mreg_type dst ->
- wt_block tf k ->
- wt_block tf (add_reload src dst k).
+Remark transf_unroll:
+ tf = transf_fun f live alloc.
Proof.
- intros. unfold add_reload. destruct src.
- case (mreg_eq m dst); intro. auto. apply wt_Bopmove. exact H0. auto.
- apply wt_Bgetstack. exact H0. exact H. auto.
+ generalize TRANSL. unfold transf_function.
+ rewrite TYPE_RTL. rewrite LIVE. rewrite ALLOC. congruence.
Qed.
-Lemma wt_add_spill:
- forall src dst k,
- loc_write_ok dst ->
- mreg_type src = Loc.type dst ->
- wt_block tf k ->
- wt_block tf (add_spill src dst k).
+Lemma valid_successor_transf:
+ forall s,
+ RTLtyping.valid_successor f s ->
+ LTLtyping.valid_successor tf s.
Proof.
- intros. unfold add_spill. destruct dst.
- case (mreg_eq src m); intro. auto.
- apply wt_Bopmove. exact H0. auto.
- apply wt_Bsetstack. generalize H. simpl. destruct s; auto.
- symmetry. exact H0. generalize H. simpl. destruct s; auto. contradiction.
- auto.
-Qed.
+ unfold RTLtyping.valid_successor, LTLtyping.valid_successor.
+ intros s [i AT].
+ rewrite transf_unroll; simpl. rewrite PTree.gmap.
+ rewrite AT. exists (transf_instr f live alloc s i). auto.
+Qed.
-Lemma wt_add_reloads:
- forall srcs dsts k,
- locs_read_ok srcs ->
- List.map Loc.type srcs = List.map mreg_type dsts ->
- wt_block tf k ->
- wt_block tf (add_reloads srcs dsts k).
-Proof.
- induction srcs; intros.
- destruct dsts. simpl; auto. simpl in H0; discriminate.
- destruct dsts; simpl in H0. discriminate. simpl.
- apply wt_add_reload. apply H; apply in_eq. congruence.
- apply IHsrcs. red; intros; apply H; apply in_cons; auto.
- congruence. auto.
-Qed.
-
-Lemma wt_reg_for:
- forall l, mreg_type (reg_for l) = Loc.type l.
-Proof.
- intros. destruct l; simpl. auto.
- case (slot_type s); reflexivity.
-Qed.
-Hint Resolve wt_reg_for: allocty.
-
-Lemma wt_regs_for_rec:
- forall locs itmps ftmps,
- (List.length locs <= List.length itmps)%nat ->
- (List.length locs <= List.length ftmps)%nat ->
- (forall r, In r itmps -> mreg_type r = Tint) ->
- (forall r, In r ftmps -> mreg_type r = Tfloat) ->
- List.map mreg_type (regs_for_rec locs itmps ftmps) = List.map Loc.type locs.
-Proof.
- induction locs; intros.
- simpl. auto.
- destruct itmps; simpl in H. omegaContradiction.
- destruct ftmps; simpl in H0. omegaContradiction.
- simpl. apply (f_equal2 (@cons typ)).
- destruct a. reflexivity. simpl. case (slot_type s).
- apply H1; apply in_eq. apply H2; apply in_eq.
- apply IHlocs. omega. omega.
- intros; apply H1; apply in_cons; auto.
- intros; apply H2; apply in_cons; auto.
-Qed.
-
-Lemma wt_regs_for:
- forall locs,
- (List.length locs <= 3)%nat ->
- List.map mreg_type (regs_for locs) = List.map Loc.type locs.
-Proof.
- intros. unfold regs_for. apply wt_regs_for_rec.
- simpl. auto. simpl. auto.
- simpl; intros; intuition; subst r; reflexivity.
- simpl; intros; intuition; subst r; reflexivity.
-Qed.
-Hint Resolve wt_regs_for: allocty.
-
-Lemma wt_add_move:
- forall src dst b,
- loc_read_ok src -> loc_write_ok dst ->
- Loc.type src = Loc.type dst ->
- wt_block tf b ->
- wt_block tf (add_move src dst b).
-Proof.
- intros. unfold add_move.
- case (Loc.eq src dst); intro.
- auto.
- destruct src. apply wt_add_spill; auto.
- destruct dst. apply wt_add_reload; auto.
- set (tmp := match slot_type s with Tint => IT1 | Tfloat => FT1 end).
- apply wt_add_reload. auto.
- simpl. unfold tmp. case (slot_type s); reflexivity.
- apply wt_add_spill. auto.
- simpl. simpl in H1. rewrite <- H1. unfold tmp. case (slot_type s); reflexivity.
- auto.
-Qed.
-
-Lemma wt_add_moves:
- forall b moves,
- (forall s d, In (s, d) moves ->
- loc_read_ok s /\ loc_write_ok d /\ Loc.type s = Loc.type d) ->
- wt_block tf b ->
- wt_block tf
- (List.fold_right (fun p k => add_move (fst p) (snd p) k) b moves).
-Proof.
- induction moves; simpl; intros.
- auto.
- destruct a as [s d]. simpl.
- elim (H s d). intros A [B C]. apply wt_add_move; auto. auto.
-Qed.
-
-Theorem wt_parallel_move:
- forall srcs dsts b,
- List.map Loc.type srcs = List.map Loc.type dsts ->
- locs_read_ok srcs ->
- locs_write_ok dsts -> wt_block tf b -> wt_block tf (parallel_move srcs dsts b).
-Proof.
- intros. unfold parallel_move. apply wt_add_moves; auto.
- intros.
- elim (parmove_prop_2 _ _ _ _ H3); intros A B.
- split. destruct A as [C|[C|C]].
- apply H0; auto. subst s; exact I. subst s; exact I.
- split. destruct B as [C|[C|C]].
- apply H1; auto. subst d; exact I. subst d; exact I.
- eapply parmove_prop_3; eauto.
-Qed.
-
-Lemma wt_add_op_move:
- forall src res s,
- Loc.type src = Loc.type res ->
- loc_read_ok src -> loc_write_ok res ->
- wt_block tf (add_op Omove (src :: nil) res s).
-Proof.
- intros. unfold add_op. simpl.
- apply wt_add_move. auto. auto. auto. constructor.
-Qed.
-
-Lemma wt_add_op_undef:
- forall res s,
- loc_write_ok res ->
- wt_block tf (add_op Oundef nil res s).
-Proof.
- intros. unfold add_op. simpl.
- apply wt_Bopundef. apply wt_add_spill. auto. auto with allocty.
- constructor.
-Qed.
-
-Lemma wt_add_op_others:
- forall op args res s,
- op <> Omove -> op <> Oundef ->
- (List.map Loc.type args, Loc.type res) = type_of_operation op ->
- locs_read_ok args ->
- loc_write_ok res ->
- wt_block tf (add_op op args res s).
-Proof.
- intros. unfold add_op.
- caseEq (is_move_operation op args). intros.
- generalize (is_move_operation_correct op args H4). tauto.
- intro. assert ((List.length args <= 3)%nat).
- replace (length args) with (length (fst (type_of_operation op))).
- apply Allocproof.length_type_of_operation.
- rewrite <- H1. simpl. apply list_length_map.
- generalize (wt_regs_for args H5); intro.
- generalize (wt_reg_for res); intro.
- apply wt_add_reloads. auto. auto.
- apply wt_Bop. auto. auto. congruence.
- apply wt_add_spill. auto. auto. constructor.
-Qed.
-
-Lemma wt_add_load:
- forall chunk addr args dst s,
- List.map Loc.type args = type_of_addressing addr ->
- Loc.type dst = type_of_chunk chunk ->
- locs_read_ok args ->
- loc_write_ok dst ->
- wt_block tf (add_load chunk addr args dst s).
-Proof.
- intros. unfold add_load.
- assert ((List.length args <= 2)%nat).
- replace (length args) with (length (type_of_addressing addr)).
- apply Allocproof.length_type_of_addressing.
- rewrite <- H. apply list_length_map.
- assert ((List.length args <= 3)%nat). omega.
- generalize (wt_regs_for args H4); intro.
- generalize (wt_reg_for dst); intro.
- apply wt_add_reloads. auto. auto.
- apply wt_Bload. congruence. congruence.
- apply wt_add_spill. auto. auto. constructor.
-Qed.
-
-Lemma wt_add_store:
- forall chunk addr args src s,
- List.map Loc.type args = type_of_addressing addr ->
- Loc.type src = type_of_chunk chunk ->
- locs_read_ok args ->
- loc_read_ok src ->
- wt_block tf (add_store chunk addr args src s).
-Proof.
- intros. unfold add_store.
- assert ((List.length args <= 2)%nat).
- replace (length args) with (length (type_of_addressing addr)).
- apply Allocproof.length_type_of_addressing.
- rewrite <- H. apply list_length_map.
- assert ((List.length (src :: args) <= 3)%nat). simpl. omega.
- generalize (wt_regs_for (src :: args) H4); intro.
- caseEq (regs_for (src :: args)).
- intro. constructor.
- intros rsrc rargs EQ. rewrite EQ in H5. simpl in H5.
- apply wt_add_reloads.
- red; intros. elim H6; intro. subst l; auto. auto.
- simpl. congruence.
- apply wt_Bstore. congruence. congruence. constructor.
-Qed.
-
-Lemma wt_add_call:
- forall sig los args res s,
- match los with inl l => Loc.type l = Tint | inr s => True end ->
- List.map Loc.type args = sig.(sig_args) ->
- Loc.type res = match sig.(sig_res) with None => Tint | Some ty => ty end ->
- locs_read_ok args ->
- match los with inl l => loc_read_ok l | inr s => True end ->
- loc_write_ok res ->
- wt_block tf (add_call sig los args res s).
-Proof.
- intros.
- assert (locs_write_ok (loc_arguments sig)).
- red; intros. generalize (loc_arguments_acceptable sig l H5).
- destruct l; simpl. auto.
- destruct s0; try contradiction. simpl. omega.
- unfold add_call. destruct los.
- apply wt_add_reload. auto. simpl; congruence.
- apply wt_parallel_move. rewrite loc_arguments_type. auto.
- auto. auto.
- apply wt_Bcall. reflexivity.
- apply wt_add_spill. auto.
- rewrite loc_result_type. auto. constructor.
- apply wt_parallel_move. rewrite loc_arguments_type. auto.
- auto. auto.
- apply wt_Bcall. auto.
- apply wt_add_spill. auto.
- rewrite loc_result_type. auto. constructor.
-Qed.
-
-Lemma wt_add_alloc:
- forall arg res s,
- Loc.type arg = Tint -> Loc.type res = Tint ->
- loc_read_ok arg -> loc_write_ok res ->
- wt_block tf (add_alloc arg res s).
-Proof.
- intros.
- unfold add_alloc. apply wt_add_reload. auto. rewrite H; reflexivity.
- apply wt_Balloc. apply wt_add_spill. auto. rewrite H0; reflexivity.
- apply wt_Bgoto.
-Qed.
-
-Lemma wt_add_cond:
- forall cond args ifso ifnot,
- List.map Loc.type args = type_of_condition cond ->
- locs_read_ok args ->
- wt_block tf (add_cond cond args ifso ifnot).
-Proof.
- intros.
- assert ((List.length args) <= 3)%nat.
- replace (length args) with (length (type_of_condition cond)).
- apply Allocproof.length_type_of_condition.
- rewrite <- H. apply list_length_map.
- generalize (wt_regs_for args H1). intro.
- unfold add_cond. apply wt_add_reloads.
- auto. auto.
- apply wt_Bcond. congruence.
-Qed.
-
-Lemma wt_add_return:
- forall sig optarg,
- option_map Loc.type optarg = sig.(sig_res) ->
- match optarg with None => True | Some arg => loc_read_ok arg end ->
- wt_block tf (add_return sig optarg).
-Proof.
- intros. unfold add_return. destruct optarg.
- apply wt_add_reload. auto. rewrite loc_result_type.
- simpl in H. destruct (sig_res sig). congruence. discriminate.
- constructor.
- apply wt_Bopundef. constructor.
-Qed.
-
-Lemma wt_add_undefs:
- forall ll b,
- wt_block tf b -> wt_block tf (add_undefs ll b).
-Proof.
- induction ll; intros.
- simpl. auto.
- simpl. destruct a. apply wt_Bopundef. auto. auto.
-Qed.
-
-Lemma wt_add_entry:
- forall params undefs s,
- List.map Loc.type params = sig_args (RTL.fn_sig f) ->
- locs_write_ok params ->
- wt_block tf (add_entry (RTL.fn_sig f) params undefs s).
-Proof.
- set (sig := RTL.fn_sig f).
- assert (sig = tf.(fn_sig)).
- unfold sig.
- assert (transf_fundef (Internal f) = Some (Internal tf)).
- unfold transf_fundef, transf_partial_fundef. rewrite TRANSL; auto.
- generalize (Allocproof.sig_function_translated _ _ H). simpl; auto.
- assert (locs_read_ok (loc_parameters sig)).
- red; unfold loc_parameters. intros.
- generalize (list_in_map_inv _ _ _ H0). intros [l1 [EQ IN]].
- subst l. generalize (loc_arguments_acceptable _ _ IN).
- destruct l1. simpl. auto.
- destruct s; try contradiction.
- simpl; intros. split. omega. rewrite <- H.
- apply loc_arguments_bounded. auto.
- intros. unfold add_entry.
- apply wt_parallel_move. rewrite loc_parameters_type. auto.
- auto. auto.
- apply wt_add_undefs. constructor.
-Qed.
+Hint Resolve alloc_acceptable allocs_acceptable: allocty.
+Hint Rewrite alloc_type alloc_types: allocty.
+Hint Resolve valid_successor_transf: allocty.
(** * Type preservation during translation from RTL to LTL *)
+Ltac WT :=
+ constructor; auto with allocty; autorewrite with allocty; auto.
+
Lemma wt_transf_instr:
forall pc instr,
- RTLtyping.wt_instr env f.(RTL.fn_sig) instr ->
- wt_block tf (transf_instr f live alloc pc instr).
+ RTLtyping.wt_instr env f instr ->
+ wt_instr tf (transf_instr f live alloc pc instr).
Proof.
- intros. inversion H; simpl.
+ intros. inv H; simpl.
(* nop *)
- constructor.
+ WT.
(* move *)
- case (Regset.mem r live!!pc).
- apply wt_add_op_move; auto with allocty.
- repeat rewrite alloc_type. auto. constructor.
- (* undef *)
- case (Regset.mem r live!!pc).
- apply wt_add_op_undef; auto with allocty.
- constructor.
+ destruct (Regset.mem r live!!pc).
+ destruct (is_redundant_move Omove (r1 :: nil) r alloc); WT.
+ WT.
(* other ops *)
- case (Regset.mem res live!!pc).
- apply wt_add_op_others; auto with allocty.
- rewrite alloc_types. rewrite alloc_type. auto.
- constructor.
+ destruct (Regset.mem res live!!pc).
+ destruct (is_redundant_move op args res alloc); WT.
+ WT.
(* load *)
- case (Regset.mem dst live!!pc).
- apply wt_add_load; auto with allocty.
- rewrite alloc_types. auto. rewrite alloc_type. auto.
- constructor.
+ destruct (Regset.mem dst live!!pc); WT.
(* store *)
- apply wt_add_store; auto with allocty.
- rewrite alloc_types. auto. rewrite alloc_type. auto.
+ WT.
(* call *)
- apply wt_add_call.
- destruct ros; simpl. rewrite alloc_type; auto. auto.
- rewrite alloc_types; auto.
- rewrite alloc_type. auto.
- auto with allocty.
+ WT.
+ destruct ros; simpl. autorewrite with allocty; auto. auto.
+ destruct ros; simpl; auto with allocty.
+ (* tailcall *)
+ WT.
+ destruct ros; simpl. autorewrite with allocty; auto. auto.
destruct ros; simpl; auto with allocty.
- auto with allocty.
+ rewrite transf_unroll; auto.
(* alloc *)
- apply wt_add_alloc; auto with allocty.
- rewrite alloc_type; auto. rewrite alloc_type; auto.
+ WT.
(* cond *)
- apply wt_add_cond. rewrite alloc_types; auto. auto with allocty.
+ WT.
(* return *)
- apply wt_add_return.
- destruct optres; simpl. rewrite alloc_type. exact H0. exact H0.
+ WT.
+ rewrite transf_unroll; simpl.
+ destruct optres; simpl. autorewrite with allocty. auto. auto.
destruct optres; simpl; auto with allocty.
Qed.
-Lemma wt_transf_instrs:
- let c := PTree.map (transf_instr f live alloc) (RTL.fn_code f) in
- forall pc b, c!pc = Some b -> wt_block tf b.
-Proof.
- intros until b.
- unfold c. rewrite PTree.gmap. caseEq (RTL.fn_code f)!pc.
- intros instr EQ. simpl. intros. injection H; intro; subst b.
- apply wt_transf_instr. eapply RTLtyping.wt_instrs; eauto.
- apply wt_rtl_function.
- simpl; intros; discriminate.
-Qed.
-
-Lemma wt_transf_entrypoint:
- let c := transf_entrypoint f live alloc
- (PTree.map (transf_instr f live alloc) (RTL.fn_code f)) in
- (forall pc b, c!pc = Some b -> wt_block tf b).
-Proof.
- simpl. unfold transf_entrypoint.
- intros pc b. rewrite PTree.gsspec.
- case (peq pc (fn_nextpc f)); intros.
- injection H; intro; subst b.
- apply wt_add_entry.
- rewrite alloc_types. eapply RTLtyping.wt_params. apply wt_rtl_function.
- auto with allocty.
- apply wt_transf_instrs with pc; auto.
-Qed.
-
End TYPING_FUNCTION.
Lemma wt_transf_function:
forall f tf,
- transf_function f = Some tf -> wt_function tf.
+ transf_function f = OK tf -> wt_function tf.
Proof.
intros. generalize H; unfold transf_function.
caseEq (type_function f). intros env TYP.
@@ -527,19 +145,27 @@ Proof.
with (live0 f live).
caseEq (regalloc f live (live0 f live) env).
intros alloc ALLOC.
- intro EQ; injection EQ; intro; subst tf.
- red. simpl. intros. eapply wt_transf_entrypoint; eauto.
- intros; discriminate.
- intros; discriminate.
- intros; discriminate.
-Qed.
+ intro EQ; injection EQ; intro.
+ assert (RTLtyping.wt_function f env). apply type_function_correct; auto.
+ inversion H1.
+ constructor; rewrite <- H0; simpl.
+ rewrite (alloc_types _ _ _ _ ALLOC). auto.
+ eapply regsalloc_acceptable; eauto.
+ eapply regalloc_norepet_norepet; eauto.
+ eapply regalloc_correct_2; eauto.
+ intros until instr. rewrite PTree.gmap.
+ caseEq (RTL.fn_code f)!pc; simpl; intros.
+ inversion H3. eapply wt_transf_instr; eauto. congruence. discriminate.
+ eapply valid_successor_transf; eauto. congruence.
+ congruence. congruence. congruence.
+Qed.
Lemma wt_transf_fundef:
forall f tf,
- transf_fundef f = Some tf -> wt_fundef tf.
+ transf_fundef f = OK tf -> wt_fundef tf.
Proof.
intros until tf; destruct f; simpl.
- caseEq (transf_function f). intros g TF EQ. inversion EQ.
+ caseEq (transf_function f); simpl. intros g TF EQ. inversion EQ.
constructor. eapply wt_transf_function; eauto.
congruence.
intros. inversion H. constructor.
@@ -547,7 +173,7 @@ Qed.
Lemma program_typing_preserved:
forall (p: RTL.program) (tp: LTL.program),
- transf_program p = Some tp ->
+ transf_program p = OK tp ->
LTLtyping.wt_program tp.
Proof.
intros; red; intros.
diff --git a/backend/Bounds.v b/backend/Bounds.v
new file mode 100644
index 0000000000000000000000000000000000000000..a0f09ce8a407800f67281de49fa6e5bca20a660d
--- /dev/null
+++ b/backend/Bounds.v
@@ -0,0 +1,357 @@
+(** Computation of resource bounds forr Linear code. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Op.
+Require Import Locations.
+Require Import Linear.
+Require Import Lineartyping.
+Require Import Conventions.
+
+(** * Resource bounds for a function *)
+
+(** The [bounds] record capture how many local and outgoing stack slots
+ and callee-save registers are used by a function. *)
+
+(** We demand that all bounds are positive or null,
+ and moreover [bound_outgoing] is greater or equal to 6.
+ These properties are used later to reason about the layout of
+ the activation record. *)
+
+Record bounds : Set := mkbounds {
+ bound_int_local: Z;
+ bound_float_local: Z;
+ bound_int_callee_save: Z;
+ bound_float_callee_save: Z;
+ bound_outgoing: Z;
+ bound_int_local_pos: bound_int_local >= 0;
+ bound_float_local_pos: bound_float_local >= 0;
+ bound_int_callee_save_pos: bound_int_callee_save >= 0;
+ bound_float_callee_save_pos: bound_float_callee_save >= 0;
+ bound_outgoing_pos: bound_outgoing >= 6
+}.
+
+(** The following predicates define the correctness of a set of bounds
+ for the code of a function. *)
+
+Section BELOW.
+
+Variable funct: function.
+Variable b: bounds.
+
+Definition mreg_within_bounds (r: mreg) :=
+ match mreg_type r with
+ | Tint => index_int_callee_save r < bound_int_callee_save b
+ | Tfloat => index_float_callee_save r < bound_float_callee_save b
+ end.
+
+Definition slot_within_bounds (s: slot) :=
+ match s with
+ | Local ofs Tint => 0 <= ofs < bound_int_local b
+ | Local ofs Tfloat => 0 <= ofs < bound_float_local b
+ | Outgoing ofs ty => 14 <= ofs /\ ofs + typesize ty <= bound_outgoing b
+ | Incoming ofs ty => 14 <= ofs /\ ofs + typesize ty <= size_arguments funct.(fn_sig)
+ end.
+
+Definition instr_within_bounds (i: instruction) :=
+ match i with
+ | Lgetstack s r => slot_within_bounds s /\ mreg_within_bounds r
+ | Lsetstack r s => slot_within_bounds s
+ | Lop op args res => mreg_within_bounds res
+ | Lload chunk addr args dst => mreg_within_bounds dst
+ | Lcall sig ros => size_arguments sig <= bound_outgoing b
+ | _ => True
+ end.
+
+End BELOW.
+
+Definition function_within_bounds (f: function) (b: bounds) : Prop :=
+ forall instr, In instr f.(fn_code) -> instr_within_bounds f b instr.
+
+(** * Inference of resource bounds for a function *)
+
+(** The resource bounds for a function are computed by a linear scan
+ of its instructions. *)
+
+Section BOUNDS.
+
+Variable f: function.
+
+(** In the proof of the [Stacking] pass, we only need to bound the
+ registers written by an instruction. Therefore, this function
+ returns these registers, ignoring registers used only as
+ arguments. *)
+
+Definition regs_of_instr (i: instruction) : list mreg :=
+ match i with
+ | Lgetstack s r => r :: nil
+ | Lsetstack r s => r :: nil
+ | Lop op args res => res :: nil
+ | Lload chunk addr args dst => dst :: nil
+ | Lstore chunk addr args src => nil
+ | Lcall sig ros => nil
+ | Ltailcall sig ros => nil
+ | Lalloc => nil
+ | Llabel lbl => nil
+ | Lgoto lbl => nil
+ | Lcond cond args lbl => nil
+ | Lreturn => nil
+ end.
+
+Definition slots_of_instr (i: instruction) : list slot :=
+ match i with
+ | Lgetstack s r => s :: nil
+ | Lsetstack r s => s :: nil
+ | _ => nil
+ end.
+
+Definition max_over_list (A: Set) (valu: A -> Z) (l: list A) : Z :=
+ List.fold_left (fun m l => Zmax m (valu l)) l 0.
+
+Definition max_over_instrs (valu: instruction -> Z) : Z :=
+ max_over_list instruction valu f.(fn_code).
+
+Definition max_over_regs_of_instr (valu: mreg -> Z) (i: instruction) : Z :=
+ max_over_list mreg valu (regs_of_instr i).
+
+Definition max_over_slots_of_instr (valu: slot -> Z) (i: instruction) : Z :=
+ max_over_list slot valu (slots_of_instr i).
+
+Definition max_over_regs_of_funct (valu: mreg -> Z) : Z :=
+ max_over_instrs (max_over_regs_of_instr valu).
+
+Definition max_over_slots_of_funct (valu: slot -> Z) : Z :=
+ max_over_instrs (max_over_slots_of_instr valu).
+
+Definition int_callee_save (r: mreg) := 1 + index_int_callee_save r.
+
+Definition float_callee_save (r: mreg) := 1 + index_float_callee_save r.
+
+Definition int_local (s: slot) :=
+ match s with Local ofs Tint => 1 + ofs | _ => 0 end.
+
+Definition float_local (s: slot) :=
+ match s with Local ofs Tfloat => 1 + ofs | _ => 0 end.
+
+Definition outgoing_slot (s: slot) :=
+ match s with Outgoing ofs ty => ofs + typesize ty | _ => 0 end.
+
+Definition outgoing_space (i: instruction) :=
+ match i with Lcall sig _ => size_arguments sig | _ => 0 end.
+
+Lemma max_over_list_pos:
+ forall (A: Set) (valu: A -> Z) (l: list A),
+ max_over_list A valu l >= 0.
+Proof.
+ intros until valu. unfold max_over_list.
+ assert (forall l z, fold_left (fun x y => Zmax x (valu y)) l z >= z).
+ induction l; simpl; intros.
+ omega. apply Zge_trans with (Zmax z (valu a)).
+ auto. apply Zle_ge. apply Zmax1. auto.
+Qed.
+
+Lemma max_over_slots_of_funct_pos:
+ forall (valu: slot -> Z), max_over_slots_of_funct valu >= 0.
+Proof.
+ intros. unfold max_over_slots_of_funct.
+ unfold max_over_instrs. apply max_over_list_pos.
+Qed.
+
+Lemma max_over_regs_of_funct_pos:
+ forall (valu: mreg -> Z), max_over_regs_of_funct valu >= 0.
+Proof.
+ intros. unfold max_over_regs_of_funct.
+ unfold max_over_instrs. apply max_over_list_pos.
+Qed.
+
+Remark Zmax_6: forall x, Zmax 6 x >= 6.
+Proof.
+ intros. apply Zle_ge. apply Zmax_bound_l. omega.
+Qed.
+
+Definition function_bounds :=
+ mkbounds
+ (max_over_slots_of_funct int_local)
+ (max_over_slots_of_funct float_local)
+ (max_over_regs_of_funct int_callee_save)
+ (max_over_regs_of_funct float_callee_save)
+ (Zmax 6
+ (Zmax (max_over_instrs outgoing_space)
+ (max_over_slots_of_funct outgoing_slot)))
+ (max_over_slots_of_funct_pos int_local)
+ (max_over_slots_of_funct_pos float_local)
+ (max_over_regs_of_funct_pos int_callee_save)
+ (max_over_regs_of_funct_pos float_callee_save)
+ (Zmax_6 _).
+
+(** We now show the correctness of the inferred bounds. *)
+
+Lemma max_over_list_bound:
+ forall (A: Set) (valu: A -> Z) (l: list A) (x: A),
+ In x l -> valu x <= max_over_list A valu l.
+Proof.
+ intros until x. unfold max_over_list.
+ assert (forall c z,
+ let f := fold_left (fun x y => Zmax x (valu y)) c z in
+ z <= f /\ (In x c -> valu x <= f)).
+ induction c; simpl; intros.
+ split. omega. tauto.
+ elim (IHc (Zmax z (valu a))); intros.
+ split. apply Zle_trans with (Zmax z (valu a)). apply Zmax1. auto.
+ intro H1; elim H1; intro.
+ subst a. apply Zle_trans with (Zmax z (valu x)).
+ apply Zmax2. auto. auto.
+ intro. elim (H l 0); intros. auto.
+Qed.
+
+Lemma max_over_instrs_bound:
+ forall (valu: instruction -> Z) i,
+ In i f.(fn_code) -> valu i <= max_over_instrs valu.
+Proof.
+ intros. unfold max_over_instrs. apply max_over_list_bound; auto.
+Qed.
+
+Lemma max_over_regs_of_funct_bound:
+ forall (valu: mreg -> Z) i r,
+ In i f.(fn_code) -> In r (regs_of_instr i) ->
+ valu r <= max_over_regs_of_funct valu.
+Proof.
+ intros. unfold max_over_regs_of_funct.
+ apply Zle_trans with (max_over_regs_of_instr valu i).
+ unfold max_over_regs_of_instr. apply max_over_list_bound. auto.
+ apply max_over_instrs_bound. auto.
+Qed.
+
+Lemma max_over_slots_of_funct_bound:
+ forall (valu: slot -> Z) i s,
+ In i f.(fn_code) -> In s (slots_of_instr i) ->
+ valu s <= max_over_slots_of_funct valu.
+Proof.
+ intros. unfold max_over_slots_of_funct.
+ apply Zle_trans with (max_over_slots_of_instr valu i).
+ unfold max_over_slots_of_instr. apply max_over_list_bound. auto.
+ apply max_over_instrs_bound. auto.
+Qed.
+
+Lemma int_callee_save_bound:
+ forall i r,
+ In i f.(fn_code) -> In r (regs_of_instr i) ->
+ index_int_callee_save r < bound_int_callee_save function_bounds.
+Proof.
+ intros. apply Zlt_le_trans with (int_callee_save r).
+ unfold int_callee_save. omega.
+ unfold function_bounds, bound_int_callee_save.
+ eapply max_over_regs_of_funct_bound; eauto.
+Qed.
+
+Lemma float_callee_save_bound:
+ forall i r,
+ In i f.(fn_code) -> In r (regs_of_instr i) ->
+ index_float_callee_save r < bound_float_callee_save function_bounds.
+Proof.
+ intros. apply Zlt_le_trans with (float_callee_save r).
+ unfold float_callee_save. omega.
+ unfold function_bounds, bound_float_callee_save.
+ eapply max_over_regs_of_funct_bound; eauto.
+Qed.
+
+Lemma int_local_slot_bound:
+ forall i ofs,
+ In i f.(fn_code) -> In (Local ofs Tint) (slots_of_instr i) ->
+ ofs < bound_int_local function_bounds.
+Proof.
+ intros. apply Zlt_le_trans with (int_local (Local ofs Tint)).
+ unfold int_local. omega.
+ unfold function_bounds, bound_int_local.
+ eapply max_over_slots_of_funct_bound; eauto.
+Qed.
+
+Lemma float_local_slot_bound:
+ forall i ofs,
+ In i f.(fn_code) -> In (Local ofs Tfloat) (slots_of_instr i) ->
+ ofs < bound_float_local function_bounds.
+Proof.
+ intros. apply Zlt_le_trans with (float_local (Local ofs Tfloat)).
+ unfold float_local. omega.
+ unfold function_bounds, bound_float_local.
+ eapply max_over_slots_of_funct_bound; eauto.
+Qed.
+
+Lemma outgoing_slot_bound:
+ forall i ofs ty,
+ In i f.(fn_code) -> In (Outgoing ofs ty) (slots_of_instr i) ->
+ ofs + typesize ty <= bound_outgoing function_bounds.
+Proof.
+ intros. change (ofs + typesize ty) with (outgoing_slot (Outgoing ofs ty)).
+ unfold function_bounds, bound_outgoing.
+ apply Zmax_bound_r. apply Zmax_bound_r.
+ eapply max_over_slots_of_funct_bound; eauto.
+Qed.
+
+Lemma size_arguments_bound:
+ forall sig ros,
+ In (Lcall sig ros) f.(fn_code) ->
+ size_arguments sig <= bound_outgoing function_bounds.
+Proof.
+ intros. change (size_arguments sig) with (outgoing_space (Lcall sig ros)).
+ unfold function_bounds, bound_outgoing.
+ apply Zmax_bound_r. apply Zmax_bound_l.
+ apply max_over_instrs_bound; auto.
+Qed.
+
+(** Consequently, all machine registers or stack slots mentioned by one
+ of the instructions of function [f] are within bounds. *)
+
+Lemma mreg_is_within_bounds:
+ forall i, In i f.(fn_code) ->
+ forall r, In r (regs_of_instr i) ->
+ mreg_within_bounds function_bounds r.
+Proof.
+ intros. unfold mreg_within_bounds.
+ case (mreg_type r).
+ eapply int_callee_save_bound; eauto.
+ eapply float_callee_save_bound; eauto.
+Qed.
+
+Lemma slot_is_within_bounds:
+ forall i, In i f.(fn_code) ->
+ forall s, In s (slots_of_instr i) -> Lineartyping.slot_valid f s ->
+ slot_within_bounds f function_bounds s.
+Proof.
+ intros. unfold slot_within_bounds.
+ destruct s.
+ destruct t.
+ split. exact H1. eapply int_local_slot_bound; eauto.
+ split. exact H1. eapply float_local_slot_bound; eauto.
+ exact H1.
+ split. exact H1. eapply outgoing_slot_bound; eauto.
+Qed.
+
+(** It follows that every instruction in the function is within bounds,
+ in the sense of the [instr_within_bounds] predicate. *)
+
+Lemma instr_is_within_bounds:
+ forall i,
+ In i f.(fn_code) ->
+ Lineartyping.wt_instr f i ->
+ instr_within_bounds f function_bounds i.
+Proof.
+ intros;
+ destruct i;
+ generalize (mreg_is_within_bounds _ H); generalize (slot_is_within_bounds _ H);
+ simpl; intros; auto.
+ inv H0. split; auto.
+ inv H0; auto.
+ eapply size_arguments_bound; eauto.
+Qed.
+
+Lemma function_is_within_bounds:
+ Lineartyping.wt_code f f.(fn_code) ->
+ function_within_bounds f function_bounds.
+Proof.
+ intros; red; intros. apply instr_is_within_bounds; auto.
+Qed.
+
+End BOUNDS.
+
diff --git a/backend/CSE.v b/backend/CSE.v
index 68010133d3f95df5b646f140d808fc8bf1167dcb..a7901d6166b5a6c566ccc918f712582568e264d6 100644
--- a/backend/CSE.v
+++ b/backend/CSE.v
@@ -251,7 +251,7 @@ Definition equation_holds
(vres: valnum) (rh: rhs) : Prop :=
match rh with
| Op op vl =>
- eval_operation ge sp op (List.map valuation vl) =
+ eval_operation ge sp op (List.map valuation vl) m =
Some (valuation vres)
| Load chunk addr vl =>
exists a,
@@ -337,6 +337,8 @@ Definition transfer (f: function) (pc: node) (before: numbering) :=
kill_loads before
| Icall sig ros args res s =>
empty_numbering
+ | Itailcall sig ros args =>
+ empty_numbering
| Ialloc arg res s =>
add_unknown before res
| Icond cond args ifso ifnot =>
@@ -373,7 +375,6 @@ Definition is_trivial_op (op: operation) : bool :=
| Ointconst _ => true
| Oaddrsymbol _ _ => true
| Oaddrstack _ => true
- | Oundef => true
| _ => false
end.
@@ -426,7 +427,8 @@ Definition transf_function (f: function) : function :=
f.(fn_nextpc)
(transf_code_wf f approxs f.(fn_code_wf)).
-Definition transf_fundef := AST.transf_fundef transf_function.
+Definition transf_fundef (f: fundef) : fundef :=
+ AST.transf_fundef transf_function f.
Definition transf_program (p: program) : program :=
transform_program transf_fundef p.
diff --git a/backend/CSEproof.v b/backend/CSEproof.v
index 79657c55f69dfc921163287e43e58a1752b05fe8..d46a39f123b1de88c3b7d6936ab2a91cf82cf84f 100644
--- a/backend/CSEproof.v
+++ b/backend/CSEproof.v
@@ -9,6 +9,7 @@ Require Import Values.
Require Import Mem.
Require Import Events.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Op.
Require Import Registers.
Require Import RTL.
@@ -218,6 +219,7 @@ Proof.
apply wf_add_load; auto.
apply wf_kill_loads; auto.
apply wf_empty_numbering.
+ apply wf_empty_numbering.
apply wf_add_unknown; auto.
Qed.
@@ -387,7 +389,7 @@ Definition rhs_evals_to
(valu: valnum -> val) (rh: rhs) (v: val) : Prop :=
match rh with
| Op op vl =>
- eval_operation ge sp op (List.map valu vl) = Some v
+ eval_operation ge sp op (List.map valu vl) m = Some v
| Load chunk addr vl =>
exists a,
eval_addressing ge sp addr (List.map valu vl) = Some a /\
@@ -468,7 +470,7 @@ Lemma add_op_satisfiable:
forall n rs op args dst v,
wf_numbering n ->
numbering_satisfiable ge sp rs m n ->
- eval_operation ge sp op rs##args = Some v ->
+ eval_operation ge sp op rs##args m = Some v ->
numbering_satisfiable ge sp (rs#dst <- v) m (add_op n dst op args).
Proof.
intros. inversion H0.
@@ -545,7 +547,7 @@ Proof.
intros. destruct H0 as [valu [A B]].
exists valu; split; intros.
generalize (A _ _ H0). destruct rh; simpl.
- auto.
+ intro. eapply eval_operation_alloc; eauto.
intros [addr [C D]]. exists addr; split. auto.
destruct addr; simpl in *; try discriminate.
eapply Mem.load_alloc_other; eauto.
@@ -569,17 +571,21 @@ Proof.
Qed.
Lemma kill_load_satisfiable:
- forall n rs m',
+ forall n rs chunk addr v m',
+ Mem.storev chunk m addr v = Some m' ->
numbering_satisfiable ge sp rs m n ->
numbering_satisfiable ge sp rs m' (kill_loads n).
Proof.
- intros. inversion H. inversion H0.
+ intros. inversion H0. inversion H1.
generalize (kill_load_eqs_incl n.(num_eqs)). intro.
exists x. split; intros.
- generalize (H1 _ _ (H3 _ H4)).
- generalize (kill_load_eqs_ops _ _ _ H4).
- destruct rh; simpl. auto. tauto.
- apply H2. assumption.
+ generalize (H2 _ _ (H4 _ H5)).
+ generalize (kill_load_eqs_ops _ _ _ H5).
+ destruct rh; simpl.
+ intros. destruct addr; simpl in H; try discriminate.
+ eapply eval_operation_store; eauto.
+ tauto.
+ apply H3. assumption.
Qed.
(** Correctness of [reg_valnum]: if it returns a register [r],
@@ -633,7 +639,7 @@ Lemma find_op_correct:
wf_numbering n ->
numbering_satisfiable ge sp rs m n ->
find_op n op args = Some r ->
- eval_operation ge sp op rs##args = Some rs#r.
+ eval_operation ge sp op rs##args m = Some rs#r.
Proof.
intros until r. intros WF [valu NH].
unfold find_op. caseEq (valnum_regs n args). intros n' vl VR FIND.
@@ -664,29 +670,6 @@ Qed.
End SATISFIABILITY.
-(** The transfer function preserves satisfiability of numberings. *)
-
-Lemma transfer_correct:
- forall ge c sp pc rs m t pc' rs' m' f n,
- exec_instr ge c sp pc rs m t pc' rs' m' ->
- c = f.(fn_code) ->
- wf_numbering n ->
- numbering_satisfiable ge sp rs m n ->
- numbering_satisfiable ge sp rs' m' (transfer f pc n).
-Proof.
- induction 1; intros; subst c; unfold transfer; rewrite H; auto.
- (* Iop *)
- eapply add_op_satisfiable; eauto.
- (* Iload *)
- eapply add_load_satisfiable; eauto.
- (* Istore *)
- eapply kill_load_satisfiable; eauto.
- (* Icall *)
- apply empty_numbering_satisfiable.
- (* Ialloc *)
- apply add_unknown_satisfiable; auto. eapply alloc_satisfiable; eauto.
-Qed.
-
(** The numberings associated to each instruction by the static analysis
are inductively satisfiable, in the following sense: the numbering
at the function entry point is satisfiable, and for any RTL execution
@@ -694,43 +677,25 @@ Qed.
satisfiability at [pc']. *)
Theorem analysis_correct_1:
- forall ge c sp pc rs m t pc' rs' m' f,
- exec_instr ge c sp pc rs m t pc' rs' m' ->
- c = f.(fn_code) ->
- numbering_satisfiable ge sp rs m (analyze f)!!pc ->
- numbering_satisfiable ge sp rs' m' (analyze f)!!pc'.
+ forall ge sp rs m f pc pc',
+ In pc' (successors f pc) ->
+ numbering_satisfiable ge sp rs m (transfer f pc (analyze f)!!pc) ->
+ numbering_satisfiable ge sp rs m (analyze f)!!pc'.
Proof.
- intros until f. intros EXEC CODE.
+ intros until pc'.
generalize (wf_analyze f pc).
unfold analyze.
caseEq (Solver.fixpoint (successors f) (fn_nextpc f)
(transfer f) (fn_entrypoint f)).
- intros res FIXPOINT WF NS.
- assert (numbering_satisfiable ge sp rs' m' (transfer f pc res!!pc)).
- eapply transfer_correct; eauto.
+ intros res FIXPOINT WF SUCC NS.
assert (Numbering.ge res!!pc' (transfer f pc res!!pc)).
eapply Solver.fixpoint_solution; eauto.
elim (fn_code_wf f pc); intro. auto.
- rewrite <- CODE in H0.
- elim (exec_instr_present _ _ _ _ _ _ _ _ _ _ EXEC H0).
- rewrite CODE in EXEC. eapply successors_correct; eauto.
- apply H0. auto.
+ unfold successors in SUCC; rewrite H in SUCC; contradiction.
+ apply H. auto.
intros. rewrite PMap.gi. apply empty_numbering_satisfiable.
Qed.
-Theorem analysis_correct_N:
- forall ge c sp pc rs m t pc' rs' m' f,
- exec_instrs ge c sp pc rs m t pc' rs' m' ->
- c = f.(fn_code) ->
- numbering_satisfiable ge sp rs m (analyze f)!!pc ->
- numbering_satisfiable ge sp rs' m' (analyze f)!!pc'.
-Proof.
- induction 1; intros.
- assumption.
- eapply analysis_correct_1; eauto.
- eauto.
-Qed.
-
Theorem analysis_correct_entry:
forall ge sp rs m f,
numbering_satisfiable ge sp rs m (analyze f)!!(f.(fn_entrypoint)).
@@ -773,49 +738,67 @@ Lemma funct_ptr_translated:
Genv.find_funct_ptr tge b = Some (transf_fundef f).
Proof (@Genv.find_funct_ptr_transf _ _ _ transf_fundef prog).
-Lemma sig_translated:
- forall (f: RTL.fundef),
- funsig (transf_fundef f) = funsig f.
+Lemma sig_preserved:
+ forall f, funsig (transf_fundef f) = funsig f.
Proof.
- intros; case f; intros; reflexivity.
+ destruct f; reflexivity.
+Qed.
+
+Lemma find_function_translated:
+ forall ros rs f,
+ find_function ge ros rs = Some f ->
+ find_function tge ros rs = Some (transf_fundef f).
+Proof.
+ intros until f; destruct ros; simpl.
+ intro. apply functions_translated; auto.
+ rewrite symbols_preserved. destruct (Genv.find_symbol ge i); intro.
+ apply funct_ptr_translated; auto.
+ discriminate.
Qed.
(** The proof of semantic preservation is a simulation argument using
diagrams of the following form:
<<
- pc, rs, m ------------------------ pc, rs, m
- | |
- | |
- v v
- pc', rs', m' --------------------- pc', rs', m'
+ st1 --------------- st2
+ | |
+ t| |t
+ | |
+ v v
+ st1'--------------- st2'
>>
Left: RTL execution in the original program. Right: RTL execution in
- the optimized program. Precondition (top): the numbering at [pc]
- (returned by the static analysis) is satisfiable. Postcondition: none.
+ the optimized program. Precondition (top) and postcondition (bottom):
+ agreement between the states, including the fact that
+ the numbering at [pc] (returned by the static analysis) is satisfiable.
*)
-Definition exec_instr_prop
- (c: code) (sp: val)
- (pc: node) (rs: regset) (m: mem) (t: trace)
- (pc': node) (rs': regset) (m': mem) : Prop :=
- forall f
- (CF: c = f.(RTL.fn_code))
- (SAT: numbering_satisfiable ge sp rs m (analyze f)!!pc),
- exec_instr tge (transf_code (analyze f) c) sp pc rs m t pc' rs' m'.
-
-Definition exec_instrs_prop
- (c: code) (sp: val)
- (pc: node) (rs: regset) (m: mem) (t: trace)
- (pc': node) (rs': regset) (m': mem) : Prop :=
- forall f
- (CF: c = f.(RTL.fn_code))
- (SAT: numbering_satisfiable ge sp rs m (analyze f)!!pc),
- exec_instrs tge (transf_code (analyze f) c) sp pc rs m t pc' rs' m'.
-
-Definition exec_function_prop
- (f: RTL.fundef) (args: list val) (m: mem) (t: trace)
- (res: val) (m': mem) : Prop :=
- exec_function tge (transf_fundef f) args m t res m'.
+Inductive match_stackframes: stackframe -> stackframe -> Prop :=
+ match_stackframes_intro:
+ forall res c sp pc rs f,
+ c = f.(RTL.fn_code) ->
+ (forall v m, numbering_satisfiable ge sp (rs#res <- v) m (analyze f)!!pc) ->
+ match_stackframes
+ (Stackframe res c sp pc rs)
+ (Stackframe res (transf_code (analyze f) c) sp pc rs).
+
+Inductive match_states: state -> state -> Prop :=
+ | match_states_intro:
+ forall s c sp pc rs m s' f
+ (CF: c = f.(RTL.fn_code))
+ (SAT: numbering_satisfiable ge sp rs m (analyze f)!!pc)
+ (STACKS: list_forall2 match_stackframes s s'),
+ match_states (State s c sp pc rs m)
+ (State s' (transf_code (analyze f) c) sp pc rs m)
+ | match_states_call:
+ forall s f args m s',
+ list_forall2 match_stackframes s s' ->
+ match_states (Callstate s f args m)
+ (Callstate s' (transf_fundef f) args m)
+ | match_states_return:
+ forall s s' v m,
+ list_forall2 match_stackframes s s' ->
+ match_states (Returnstate s v m)
+ (Returnstate s' v m).
Ltac TransfInstr :=
match goal with
@@ -826,34 +809,49 @@ Ltac TransfInstr :=
unfold option_map; rewrite H1; reflexivity ]
end.
-(** The proof of simulation is by structural induction on the evaluation
- derivation for the source program. *)
+(** The proof of simulation is a case analysis over the transition
+ in the source code. *)
-Lemma transf_function_correct:
- forall f args m t res m',
- exec_function ge f args m t res m' ->
- exec_function_prop f args m t res m'.
+Lemma transf_step_correct:
+ forall s1 t s2, step ge s1 t s2 ->
+ forall s1' (MS: match_states s1 s1'),
+ exists s2', step tge s1' t s2' /\ match_states s2 s2'.
Proof.
- apply (exec_function_ind_3 ge
- exec_instr_prop exec_instrs_prop exec_function_prop);
- intros; red; intros; try TransfInstr.
+ induction 1; intros; inv MS; try (TransfInstr; intro C).
+
(* Inop *)
- intro; apply exec_Inop; auto.
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' rs m); split.
+ apply exec_Inop; auto.
+ econstructor; eauto.
+ apply analysis_correct_1 with pc.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H; auto.
+
(* Iop *)
- assert (eval_operation tge sp op rs##args = Some v).
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' (rs#res <- v) m); split.
+ assert (eval_operation tge sp op rs##args m = Some v).
rewrite <- H0. apply eval_operation_preserved. exact symbols_preserved.
+ generalize C; clear C.
case (is_trivial_op op).
intro. eapply exec_Iop'; eauto.
caseEq (find_op (analyze f)!!pc op args). intros r FIND CODE.
eapply exec_Iop'; eauto. simpl.
- assert (eval_operation ge sp op rs##args = Some rs#r).
+ assert (eval_operation ge sp op rs##args m = Some rs#r).
eapply find_op_correct; eauto.
eapply wf_analyze; eauto.
congruence.
- intros. eapply exec_Iop'; eauto.
+ intros. eapply exec_Iop'; eauto.
+ econstructor; eauto.
+ apply analysis_correct_1 with pc.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H.
+ eapply add_op_satisfiable; eauto. apply wf_analyze.
+
(* Iload *)
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' (rs#dst <- v) m); split.
assert (eval_addressing tge sp addr rs##args = Some a).
rewrite <- H0. apply eval_addressing_preserved. exact symbols_preserved.
+ generalize C; clear C.
caseEq (find_load (analyze f)!!pc chunk addr args). intros r FIND CODE.
eapply exec_Iop'; eauto. simpl.
assert (exists a, eval_addressing ge sp addr rs##args = Some a
@@ -862,52 +860,125 @@ Proof.
eapply wf_analyze; eauto.
elim H3; intros a' [A B].
congruence.
- intros. eapply exec_Iload'; eauto.
+ intros. eapply exec_Iload'; eauto.
+ econstructor; eauto.
+ apply analysis_correct_1 with pc.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H.
+ eapply add_load_satisfiable; eauto. apply wf_analyze.
+
(* Istore *)
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' rs m'); split.
assert (eval_addressing tge sp addr rs##args = Some a).
rewrite <- H0. apply eval_addressing_preserved. exact symbols_preserved.
- intro; eapply exec_Istore; eauto.
+ eapply exec_Istore; eauto.
+ econstructor; eauto.
+ apply analysis_correct_1 with pc.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H.
+ eapply kill_load_satisfiable; eauto.
+
(* Icall *)
- assert (find_function tge ros rs = Some (transf_fundef f)).
- destruct ros; simpl in H0; simpl.
- apply functions_translated; auto.
- rewrite symbols_preserved. destruct (Genv.find_symbol ge i).
- apply funct_ptr_translated; auto. discriminate.
- intro; eapply exec_Icall with (f := transf_fundef f); eauto.
- generalize (sig_translated f); congruence.
+ exploit find_function_translated; eauto. intro FIND'.
+ econstructor; split.
+ eapply exec_Icall with (f := transf_fundef f); eauto.
+ apply sig_preserved.
+ econstructor; eauto.
+ constructor; auto.
+ econstructor; eauto.
+ intros. apply analysis_correct_1 with pc.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H.
+ apply empty_numbering_satisfiable.
+
+ (* Itailcall *)
+ exploit find_function_translated; eauto. intro FIND'.
+ econstructor; split.
+ eapply exec_Itailcall with (f := transf_fundef f); eauto.
+ apply sig_preserved.
+ econstructor; eauto.
+
(* Ialloc *)
- intro; eapply exec_Ialloc; eauto.
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' (rs#res <- (Vptr b Int.zero)) m'); split.
+ eapply exec_Ialloc; eauto.
+ econstructor; eauto.
+ apply analysis_correct_1 with pc.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H.
+ apply add_unknown_satisfiable. apply wf_analyze; auto.
+ eapply alloc_satisfiable; eauto.
+
(* Icond true *)
- intro; eapply exec_Icond_true; eauto.
+ econstructor; split.
+ eapply exec_Icond_true; eauto.
+ econstructor; eauto.
+ apply analysis_correct_1 with pc.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H; auto.
+
(* Icond false *)
- intro; eapply exec_Icond_false; eauto.
- (* refl *)
- apply exec_refl.
- (* one *)
- apply exec_one; auto.
- (* trans *)
- eapply exec_trans; eauto. apply H2; auto.
- eapply analysis_correct_N; eauto.
+ econstructor; split.
+ eapply exec_Icond_false; eauto.
+ econstructor; eauto.
+ apply analysis_correct_1 with pc.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H; auto.
+
+ (* Ireturn *)
+ econstructor; split.
+ eapply exec_Ireturn; eauto.
+ constructor; auto.
+
(* internal function *)
- intro. unfold transf_function; simpl; eapply exec_funct_internal; simpl; eauto.
- eapply H1; eauto. eapply analysis_correct_entry; eauto.
+ simpl. econstructor; split.
+ eapply exec_function_internal; eauto.
+ simpl. econstructor; eauto.
+ apply analysis_correct_entry.
+
(* external function *)
- unfold transf_function; simpl. apply exec_funct_external; auto.
+ simpl. econstructor; split.
+ eapply exec_function_external; eauto.
+ econstructor; eauto.
+
+ (* return *)
+ inv H3. inv H1.
+ econstructor; split.
+ eapply exec_return; eauto.
+ econstructor; eauto.
+Qed.
+
+Lemma transf_initial_states:
+ forall st1, initial_state prog st1 ->
+ exists st2, initial_state tprog st2 /\ match_states st1 st2.
+Proof.
+ intros. inversion H.
+ exists (Callstate nil (transf_fundef f) nil (Genv.init_mem tprog)); split.
+ econstructor; eauto.
+ change (prog_main tprog) with (prog_main prog).
+ rewrite symbols_preserved. eauto.
+ apply funct_ptr_translated; auto.
+ rewrite <- H2. apply sig_preserved.
+ replace (Genv.init_mem tprog) with (Genv.init_mem prog).
+ constructor. constructor. auto.
+ symmetry. unfold tprog, transf_program. apply Genv.init_mem_transf.
+Qed.
+
+Lemma transf_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 -> final_state st1 r -> final_state st2 r.
+Proof.
+ intros. inv H0. inv H. inv H4. constructor.
Qed.
Theorem transf_program_correct:
- forall (t: trace) (r: val),
- exec_program prog t r -> exec_program tprog t r.
-Proof.
- intros t r [fptr [f [m [FINDS [FINDF [SIG EXEC]]]]]].
- red. exists fptr; exists (transf_fundef f); exists m.
- split. change (prog_main tprog) with (prog_main prog).
- rewrite symbols_preserved. assumption.
- split. apply funct_ptr_translated; auto.
- split. generalize (sig_translated f); congruence.
- apply transf_function_correct.
- unfold tprog, transf_program. rewrite Genv.init_mem_transf.
- exact EXEC.
+ forall (beh: program_behavior),
+ exec_program prog beh -> exec_program tprog beh.
+Proof.
+ unfold exec_program; intros.
+ eapply simulation_step_preservation; eauto.
+ eexact transf_initial_states.
+ eexact transf_final_states.
+ exact transf_step_correct.
Qed.
End PRESERVATION.
diff --git a/backend/Cminor.v b/backend/Cminor.v
index 9ed5e19d684d5b1e86651a375f83adedfd65a2a2..2b9945ac7599714b3a5bec486a9937ed1d22407b 100644
--- a/backend/Cminor.v
+++ b/backend/Cminor.v
@@ -8,41 +8,79 @@ Require Import Floats.
Require Import Events.
Require Import Values.
Require Import Mem.
-Require Import Op.
Require Import Globalenvs.
+Require Import Switch.
(** * Abstract syntax *)
(** Cminor is a low-level imperative language structured in expressions,
- statements, functions and programs. Expressions include
- reading local variables, reading and writing store locations,
- arithmetic operations, function calls, and conditional expressions
- (similar to [e1 ? e2 : e3] in C). The [Elet] and [Eletvar] constructs
- enable sharing the computations of subexpressions. De Bruijn notation
- is used: [Eletvar n] refers to the value bound by then [n+1]-th enclosing
- [Elet] construct.
-
- A variant [condexpr] of [expr] is used to represent expressions
- which are evaluated for their boolean value only and not their exact value.
-*)
+ statements, functions and programs. We first define the constants
+ and operators that occur within expressions. *)
+
+Inductive constant : Set :=
+ | Ointconst: int -> constant (**r integer constant *)
+ | Ofloatconst: float -> constant (**r floating-point constant *)
+ | Oaddrsymbol: ident -> int -> constant (**r address of the symbol plus the offset *)
+ | Oaddrstack: int -> constant. (**r stack pointer plus the given offset *)
+
+Inductive unary_operation : Set :=
+ | Ocast8unsigned: unary_operation (**r 8-bit zero extension *)
+ | Ocast8signed: unary_operation (**r 8-bit sign extension *)
+ | Ocast16unsigned: unary_operation (**r 16-bit zero extension *)
+ | Ocast16signed: unary_operation (**r 16-bit sign extension *)
+ | Onegint: unary_operation (**r integer opposite *)
+ | Onotbool: unary_operation (**r boolean negation *)
+ | Onotint: unary_operation (**r bitwise complement *)
+ | Onegf: unary_operation (**r float opposite *)
+ | Oabsf: unary_operation (**r float absolute value *)
+ | Osingleoffloat: unary_operation (**r float truncation *)
+ | Ointoffloat: unary_operation (**r integer to float *)
+ | Ofloatofint: unary_operation (**r float to signed integer *)
+ | Ofloatofintu: unary_operation. (**r float to unsigned integer *)
+
+Inductive binary_operation : Set :=
+ | Oadd: binary_operation (**r integer addition *)
+ | Osub: binary_operation (**r integer subtraction *)
+ | Omul: binary_operation (**r integer multiplication *)
+ | Odiv: binary_operation (**r integer signed division *)
+ | Odivu: binary_operation (**r integer unsigned division *)
+ | Omod: binary_operation (**r integer signed modulus *)
+ | Omodu: binary_operation (**r integer unsigned modulus *)
+ | Oand: binary_operation (**r bitwise ``and'' *)
+ | Oor: binary_operation (**r bitwise ``or'' *)
+ | Oxor: binary_operation (**r bitwise ``xor'' *)
+ | Oshl: binary_operation (**r left shift *)
+ | Oshr: binary_operation (**r right signed shift *)
+ | Oshru: binary_operation (**r right unsigned shift *)
+ | Oaddf: binary_operation (**r float addition *)
+ | Osubf: binary_operation (**r float subtraction *)
+ | Omulf: binary_operation (**r float multiplication *)
+ | Odivf: binary_operation (**r float division *)
+ | Ocmp: comparison -> binary_operation (**r integer signed comparison *)
+ | Ocmpu: comparison -> binary_operation (**r integer unsigned comparison *)
+ | Ocmpf: comparison -> binary_operation. (**r float comparison *)
+
+(** Expressions include reading local variables, constants and
+ arithmetic operations, reading and writing store locations,
+ function calls, and conditional expressions
+ (similar to [e1 ? e2 : e3] in C).
+ The [Elet] and [Eletvar] constructs enable sharing the computations
+ of subexpressions. De Bruijn notation is used: [Eletvar n] refers
+ to the value bound by then [n+1]-th enclosing [Elet] construct. *)
Inductive expr : Set :=
| Evar : ident -> expr
- | Eop : operation -> exprlist -> expr
- | Eload : memory_chunk -> addressing -> exprlist -> expr
- | Estore : memory_chunk -> addressing -> exprlist -> expr -> expr
+ | Econst : constant -> expr
+ | Eunop : unary_operation -> expr -> expr
+ | Ebinop : binary_operation -> expr -> expr -> expr
+ | Eload : memory_chunk -> expr -> expr
+ | Estore : memory_chunk -> expr -> expr -> expr
| Ecall : signature -> expr -> exprlist -> expr
- | Econdition : condexpr -> expr -> expr -> expr
+ | Econdition : expr -> expr -> expr -> expr
| Elet : expr -> expr -> expr
| Eletvar : nat -> expr
| Ealloc : expr -> expr
-with condexpr : Set :=
- | CEtrue: condexpr
- | CEfalse: condexpr
- | CEcond: condition -> exprlist -> condexpr
- | CEcondition : condexpr -> condexpr -> condexpr -> condexpr
-
with exprlist : Set :=
| Enil: exprlist
| Econs: expr -> exprlist -> exprlist.
@@ -57,12 +95,13 @@ Inductive stmt : Set :=
| Sexpr: expr -> stmt
| Sassign : ident -> expr -> stmt
| Sseq: stmt -> stmt -> stmt
- | Sifthenelse: condexpr -> stmt -> stmt -> stmt
+ | Sifthenelse: expr -> stmt -> stmt -> stmt
| Sloop: stmt -> stmt
| Sblock: stmt -> stmt
| Sexit: nat -> stmt
| Sswitch: expr -> list (int * nat) -> nat -> stmt
- | Sreturn: option expr -> stmt.
+ | Sreturn: option expr -> stmt
+ | Stailcall: signature -> expr -> exprlist -> stmt.
(** Functions are composed of a signature, a list of parameter names,
a list of local variables, and a statement representing
@@ -97,30 +136,31 @@ Definition funsig (fd: fundef) :=
Inductive outcome: Set :=
| Out_normal: outcome (**r continue in sequence *)
| Out_exit: nat -> outcome (**r terminate [n+1] enclosing blocks *)
- | Out_return: option val -> outcome. (**r return immediately to caller *)
-
-Definition outcome_result_value
- (out: outcome) (ot: option typ) (v: val) : Prop :=
- match out, ot with
- | Out_normal, None => v = Vundef
- | Out_return None, None => v = Vundef
- | Out_return (Some v'), Some ty => v = v'
- | _, _ => False
- end.
+ | Out_return: option val -> outcome (**r return immediately to caller *)
+ | Out_tailcall_return: val -> outcome. (**r already returned to caller via a tailcall *)
Definition outcome_block (out: outcome) : outcome :=
match out with
- | Out_normal => Out_normal
| Out_exit O => Out_normal
| Out_exit (S n) => Out_exit n
- | Out_return optv => Out_return optv
+ | out => out
+ end.
+
+Definition outcome_result_value
+ (out: outcome) (retsig: option typ) (vres: val) : Prop :=
+ match out, retsig with
+ | Out_normal, None => vres = Vundef
+ | Out_return None, None => vres = Vundef
+ | Out_return (Some v), Some ty => vres = v
+ | Out_tailcall_return v, _ => vres = v
+ | _, _ => False
end.
-Fixpoint switch_target (n: int) (dfl: nat) (cases: list (int * nat))
- {struct cases} : nat :=
- match cases with
- | nil => dfl
- | (n1, lbl1) :: rem => if Int.eq n n1 then lbl1 else switch_target n dfl rem
+Definition outcome_free_mem
+ (out: outcome) (m: mem) (sp: block) : mem :=
+ match out with
+ | Out_tailcall_return _ => m
+ | _ => Mem.free m sp
end.
(** Three kinds of evaluation environments are involved:
@@ -154,10 +194,105 @@ Section RELSEM.
Variable ge: genv.
-(** Evaluation of an expression: [eval_expr ge sp le e m a m' v]
+(** Evaluation of constants and operator applications.
+ [None] is returned when the computation is undefined, e.g.
+ if arguments are of the wrong types, or in case of an integer division
+ by zero. *)
+
+Definition eval_constant (sp: val) (cst: constant) : option val :=
+ match cst with
+ | Ointconst n => Some (Vint n)
+ | Ofloatconst n => Some (Vfloat n)
+ | Oaddrsymbol s ofs =>
+ match Genv.find_symbol ge s with
+ | None => None
+ | Some b => Some (Vptr b ofs)
+ end
+ | Oaddrstack ofs =>
+ match sp with
+ | Vptr b n => Some (Vptr b (Int.add n ofs))
+ | _ => None
+ end
+ end.
+
+Definition eval_unop (op: unary_operation) (arg: val) : option val :=
+ match op, arg with
+ | Ocast8unsigned, _ => Some (Val.cast8unsigned arg)
+ | Ocast8signed, _ => Some (Val.cast8signed arg)
+ | Ocast16unsigned, _ => Some (Val.cast16unsigned arg)
+ | Ocast16signed, _ => Some (Val.cast16signed arg)
+ | Onegint, Vint n1 => Some (Vint (Int.neg n1))
+ | Onotbool, Vint n1 => Some (Val.of_bool (Int.eq n1 Int.zero))
+ | Onotbool, Vptr b1 n1 => Some Vfalse
+ | Onotint, Vint n1 => Some (Vint (Int.not n1))
+ | Onegf, Vfloat f1 => Some (Vfloat (Float.neg f1))
+ | Oabsf, Vfloat f1 => Some (Vfloat (Float.abs f1))
+ | Osingleoffloat, _ => Some (Val.singleoffloat arg)
+ | Ointoffloat, Vfloat f1 => Some (Vint (Float.intoffloat f1))
+ | Ofloatofint, Vint n1 => Some (Vfloat (Float.floatofint n1))
+ | Ofloatofintu, Vint n1 => Some (Vfloat (Float.floatofintu n1))
+ | _, _ => None
+ end.
+
+Definition eval_compare_null (c: comparison) (n: int) : option val :=
+ if Int.eq n Int.zero
+ then match c with Ceq => Some Vfalse | Cne => Some Vtrue | _ => None end
+ else None.
+
+Definition eval_binop
+ (op: binary_operation) (arg1 arg2: val) (m: mem): option val :=
+ match op, arg1, arg2 with
+ | Oadd, Vint n1, Vint n2 => Some (Vint (Int.add n1 n2))
+ | Oadd, Vint n1, Vptr b2 n2 => Some (Vptr b2 (Int.add n2 n1))
+ | Oadd, Vptr b1 n1, Vint n2 => Some (Vptr b1 (Int.add n1 n2))
+ | Osub, Vint n1, Vint n2 => Some (Vint (Int.sub n1 n2))
+ | Osub, Vptr b1 n1, Vint n2 => Some (Vptr b1 (Int.sub n1 n2))
+ | Osub, Vptr b1 n1, Vptr b2 n2 =>
+ if eq_block b1 b2 then Some (Vint (Int.sub n1 n2)) else None
+ | Omul, Vint n1, Vint n2 => Some (Vint (Int.mul n1 n2))
+ | Odiv, Vint n1, Vint n2 =>
+ if Int.eq n2 Int.zero then None else Some (Vint (Int.divs n1 n2))
+ | Odivu, Vint n1, Vint n2 =>
+ if Int.eq n2 Int.zero then None else Some (Vint (Int.divu n1 n2))
+ | Omod, Vint n1, Vint n2 =>
+ if Int.eq n2 Int.zero then None else Some (Vint (Int.mods n1 n2))
+ | Omodu, Vint n1, Vint n2 =>
+ if Int.eq n2 Int.zero then None else Some (Vint (Int.modu n1 n2))
+ | Oand, Vint n1, Vint n2 => Some (Vint (Int.and n1 n2))
+ | Oor, Vint n1, Vint n2 => Some (Vint (Int.or n1 n2))
+ | Oxor, Vint n1, Vint n2 => Some (Vint (Int.xor n1 n2))
+ | Oshl, Vint n1, Vint n2 =>
+ if Int.ltu n2 (Int.repr 32) then Some (Vint (Int.shl n1 n2)) else None
+ | Oshr, Vint n1, Vint n2 =>
+ if Int.ltu n2 (Int.repr 32) then Some (Vint (Int.shr n1 n2)) else None
+ | Oshru, Vint n1, Vint n2 =>
+ if Int.ltu n2 (Int.repr 32) then Some (Vint (Int.shru n1 n2)) else None
+ | Oaddf, Vfloat f1, Vfloat f2 => Some (Vfloat (Float.add f1 f2))
+ | Osubf, Vfloat f1, Vfloat f2 => Some (Vfloat (Float.sub f1 f2))
+ | Omulf, Vfloat f1, Vfloat f2 => Some (Vfloat (Float.mul f1 f2))
+ | Odivf, Vfloat f1, Vfloat f2 => Some (Vfloat (Float.div f1 f2))
+ | Ocmp c, Vint n1, Vint n2 =>
+ Some (Val.of_bool(Int.cmp c n1 n2))
+ | Ocmp c, Vptr b1 n1, Vptr b2 n2 =>
+ if valid_pointer m b1 (Int.signed n1)
+ && valid_pointer m b2 (Int.signed n2) then
+ if eq_block b1 b2 then Some(Val.of_bool(Int.cmp c n1 n2)) else None
+ else
+ None
+ | Ocmp c, Vptr b1 n1, Vint n2 => eval_compare_null c n2
+ | Ocmp c, Vint n1, Vptr b2 n2 => eval_compare_null c n1
+ | Ocmpu c, Vint n1, Vint n2 =>
+ Some (Val.of_bool(Int.cmpu c n1 n2))
+ | Ocmpf c, Vfloat f1, Vfloat f2 =>
+ Some (Val.of_bool (Float.cmp c f1 f2))
+ | _, _, _ => None
+ end.
+
+(** Evaluation of an expression: [eval_expr ge sp le e m a t m' v]
states that expression [a], in initial local environment [e] and
memory state [m], evaluates to value [v]. [m'] is the final
memory state, reflecting memory stores possibly performed by [a].
+ [t] is the trace of I/O events generated during the evaluation.
Expressions do not assign variables, therefore the local environment
[e] is unchanged. [ge] and [le] are the global environment and let
environment respectively, and are unchanged during evaluation. [sp]
@@ -172,25 +307,34 @@ Inductive eval_expr:
forall sp le e m id v,
PTree.get id e = Some v ->
eval_expr sp le e m (Evar id) E0 m v
- | eval_Eop:
- forall sp le e m op al t m1 vl v,
- eval_exprlist sp le e m al t m1 vl ->
- eval_operation ge sp op vl = Some v ->
- eval_expr sp le e m (Eop op al) t m1 v
+ | eval_Econst:
+ forall sp le e m cst v,
+ eval_constant sp cst = Some v ->
+ eval_expr sp le e m (Econst cst) E0 m v
+ | eval_Eunop:
+ forall sp le e m op a t m1 v1 v,
+ eval_expr sp le e m a t m1 v1 ->
+ eval_unop op v1 = Some v ->
+ eval_expr sp le e m (Eunop op a) t m1 v
+ | eval_Ebinop:
+ forall sp le e m op a1 a2 t1 m1 v1 t2 m2 v2 t v,
+ eval_expr sp le e m a1 t1 m1 v1 ->
+ eval_expr sp le e m1 a2 t2 m2 v2 ->
+ eval_binop op v1 v2 m2 = Some v ->
+ t = t1 ** t2 ->
+ eval_expr sp le e m (Ebinop op a1 a2) t m2 v
| eval_Eload:
- forall sp le e m chunk addr al t m1 v vl a,
- eval_exprlist sp le e m al t m1 vl ->
- eval_addressing ge sp addr vl = Some a ->
- Mem.loadv chunk m1 a = Some v ->
- eval_expr sp le e m (Eload chunk addr al) t m1 v
+ forall sp le e m chunk a t m1 v1 v,
+ eval_expr sp le e m a t m1 v1 ->
+ Mem.loadv chunk m1 v1 = Some v ->
+ eval_expr sp le e m (Eload chunk a) t m1 v
| eval_Estore:
- forall sp le e m chunk addr al b t t1 m1 vl t2 m2 m3 v a,
- eval_exprlist sp le e m al t1 m1 vl ->
- eval_expr sp le e m1 b t2 m2 v ->
- eval_addressing ge sp addr vl = Some a ->
- Mem.storev chunk m2 a v = Some m3 ->
+ forall sp le e m chunk a1 a2 t t1 m1 v1 t2 m2 v2 m3,
+ eval_expr sp le e m a1 t1 m1 v1 ->
+ eval_expr sp le e m1 a2 t2 m2 v2 ->
+ Mem.storev chunk m2 v1 v2 = Some m3 ->
t = t1 ** t2 ->
- eval_expr sp le e m (Estore chunk addr al b) t m3 v
+ eval_expr sp le e m (Estore chunk a1 a2) t m3 v2
| eval_Ecall:
forall sp le e m sig a bl t t1 m1 t2 m2 t3 m3 vf vargs vres f,
eval_expr sp le e m a t1 m1 vf ->
@@ -201,11 +345,12 @@ Inductive eval_expr:
t = t1 ** t2 ** t3 ->
eval_expr sp le e m (Ecall sig a bl) t m3 vres
| eval_Econdition:
- forall sp le e m a b c t t1 m1 v1 t2 m2 v2,
- eval_condexpr sp le e m a t1 m1 v1 ->
- eval_expr sp le e m1 (if v1 then b else c) t2 m2 v2 ->
+ forall sp le e m a1 a2 a3 t t1 m1 v1 b1 t2 m2 v2,
+ eval_expr sp le e m a1 t1 m1 v1 ->
+ Val.bool_of_val v1 b1 ->
+ eval_expr sp le e m1 (if b1 then a2 else a3) t2 m2 v2 ->
t = t1 ** t2 ->
- eval_expr sp le e m (Econdition a b c) t m2 v2
+ eval_expr sp le e m (Econdition a1 a2 a3) t m2 v2
| eval_Elet:
forall sp le e m a b t t1 m1 v1 t2 m2 v2,
eval_expr sp le e m a t1 m1 v1 ->
@@ -222,33 +367,6 @@ Inductive eval_expr:
Mem.alloc m1 0 (Int.signed n) = (m2, b) ->
eval_expr sp le e m (Ealloc a) t m2 (Vptr b Int.zero)
-(** Evaluation of a condition expression:
- [eval_condexpr ge sp le e m a m' b]
- states that condition expression [a] evaluates to the boolean value [b].
- The other parameters are as in [eval_expr].
-*)
-
-with eval_condexpr:
- val -> letenv -> env ->
- mem -> condexpr -> trace -> mem -> bool -> Prop :=
- | eval_CEtrue:
- forall sp le e m,
- eval_condexpr sp le e m CEtrue E0 m true
- | eval_CEfalse:
- forall sp le e m,
- eval_condexpr sp le e m CEfalse E0 m false
- | eval_CEcond:
- forall sp le e m cond al t1 m1 vl b,
- eval_exprlist sp le e m al t1 m1 vl ->
- eval_condition cond vl = Some b ->
- eval_condexpr sp le e m (CEcond cond al) t1 m1 b
- | eval_CEcondition:
- forall sp le e m a b c t t1 m1 vb1 t2 m2 vb2,
- eval_condexpr sp le e m a t1 m1 vb1 ->
- eval_condexpr sp le e m1 (if vb1 then b else c) t2 m2 vb2 ->
- t = t1 ** t2 ->
- eval_condexpr sp le e m (CEcondition a b c) t m2 vb2
-
(** Evaluation of a list of expressions:
[eval_exprlist ge sp le al m a m' vl]
states that the list [al] of expressions evaluate
@@ -272,6 +390,7 @@ with eval_exprlist:
(** Evaluation of a function invocation: [eval_funcall ge m f args m' res]
means that the function [f], applied to the arguments [args] in
memory state [m], returns the value [res] in modified memory state [m'].
+ [t] is the trace of observable events generated during the invocation.
*)
with eval_funcall:
@@ -283,7 +402,7 @@ with eval_funcall:
set_locals f.(fn_vars) (set_params vargs f.(fn_params)) = e ->
exec_stmt (Vptr sp Int.zero) e m1 f.(fn_body) t e2 m2 out ->
outcome_result_value out f.(fn_sig).(sig_res) vres ->
- eval_funcall m (Internal f) vargs t (Mem.free m2 sp) vres
+ eval_funcall m (Internal f) vargs t (outcome_free_mem out m2 sp) vres
| eval_funcall_external:
forall ef m args t res,
event_match ef args t res ->
@@ -291,7 +410,10 @@ with eval_funcall:
(** Execution of a statement: [exec_stmt ge sp e m s e' m' out]
means that statement [s] executes with outcome [out].
- The other parameters are as in [eval_expr]. *)
+ [e] is the initial environment and [m] is the initial memory state.
+ [e'] is the final environment, reflecting variable assignments performed
+ by [s]. [m'] is the final memory state, reflecting memory stores
+ performed by [s]. The other parameters are as in [eval_expr]. *)
with exec_stmt:
val ->
@@ -309,9 +431,10 @@ with exec_stmt:
eval_expr sp nil e m a t m1 v ->
exec_stmt sp e m (Sassign id a) t (PTree.set id v e) m1 Out_normal
| exec_Sifthenelse:
- forall sp e m a s1 s2 t t1 m1 v1 t2 e2 m2 out,
- eval_condexpr sp nil e m a t1 m1 v1 ->
- exec_stmt sp e m1 (if v1 then s1 else s2) t2 e2 m2 out ->
+ forall sp e m a s1 s2 t t1 m1 v1 b1 t2 e2 m2 out,
+ eval_expr sp nil e m a t1 m1 v1 ->
+ Val.bool_of_val v1 b1 ->
+ exec_stmt sp e m1 (if b1 then s1 else s2) t2 e2 m2 out ->
t = t1 ** t2 ->
exec_stmt sp e m (Sifthenelse a s1 s2) t e2 m2 out
| exec_Sseq_continue:
@@ -354,13 +477,29 @@ with exec_stmt:
| exec_Sreturn_some:
forall sp e m a t m1 v,
eval_expr sp nil e m a t m1 v ->
- exec_stmt sp e m (Sreturn (Some a)) t e m1 (Out_return (Some v)).
+ exec_stmt sp e m (Sreturn (Some a)) t e m1 (Out_return (Some v))
+ | exec_Stailcall:
+ forall sp e m sig a bl t t1 m1 t2 m2 t3 m3 vf vargs vres f,
+ eval_expr (Vptr sp Int.zero) nil e m a t1 m1 vf ->
+ eval_exprlist (Vptr sp Int.zero) nil e m1 bl t2 m2 vargs ->
+ Genv.find_funct ge vf = Some f ->
+ funsig f = sig ->
+ eval_funcall (Mem.free m2 sp) f vargs t3 m3 vres ->
+ t = t1 ** t2 ** t3 ->
+ exec_stmt (Vptr sp Int.zero) e m (Stailcall sig a bl) t e m3 (Out_tailcall_return vres).
+
+Scheme eval_expr_ind4 := Minimality for eval_expr Sort Prop
+ with eval_exprlist_ind4 := Minimality for eval_exprlist Sort Prop
+ with eval_funcall_ind4 := Minimality for eval_funcall Sort Prop
+ with exec_stmt_ind4 := Minimality for exec_stmt Sort Prop.
End RELSEM.
-(** Execution of a whole program: [exec_program p r]
+(** Execution of a whole program: [exec_program p t r]
holds if the application of [p]'s main function to no arguments
- in the initial memory state for [p] eventually returns value [r]. *)
+ in the initial memory state for [p] performs the input/output
+ operations described in the trace [t], and eventually returns value [r].
+*)
Definition exec_program (p: program) (t: trace) (r: val) : Prop :=
let ge := Genv.globalenv p in
diff --git a/backend/CminorSel.v b/backend/CminorSel.v
new file mode 100644
index 0000000000000000000000000000000000000000..331105eadf63a0531c1f7a1e70dbfb94c44b3697
--- /dev/null
+++ b/backend/CminorSel.v
@@ -0,0 +1,296 @@
+(** The Cminor language after instruction selection. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Integers.
+Require Import Floats.
+Require Import Events.
+Require Import Values.
+Require Import Mem.
+Require Import Cminor.
+Require Import Op.
+Require Import Globalenvs.
+Require Import Switch.
+
+(** * Abstract syntax *)
+
+(** CminorSel programs share the general structure of Cminor programs:
+ functions, statements and expressions. However, CminorSel uses
+ machine-dependent operations, addressing modes and conditions,
+ as defined in module [Op] and used in lower-level intermediate
+ languages ([RTL] and below). Moreover, a variant [condexpr] of [expr]
+ is used to represent expressions which are evaluated for their
+ boolean value only and not their exact value.
+*)
+
+Inductive expr : Set :=
+ | Evar : ident -> expr
+ | Eop : operation -> exprlist -> expr
+ | Eload : memory_chunk -> addressing -> exprlist -> expr
+ | Estore : memory_chunk -> addressing -> exprlist -> expr -> expr
+ | Ecall : signature -> expr -> exprlist -> expr
+ | Econdition : condexpr -> expr -> expr -> expr
+ | Elet : expr -> expr -> expr
+ | Eletvar : nat -> expr
+ | Ealloc : expr -> expr
+
+with condexpr : Set :=
+ | CEtrue: condexpr
+ | CEfalse: condexpr
+ | CEcond: condition -> exprlist -> condexpr
+ | CEcondition : condexpr -> condexpr -> condexpr -> condexpr
+
+with exprlist : Set :=
+ | Enil: exprlist
+ | Econs: expr -> exprlist -> exprlist.
+
+(** Statements are as in Cminor, except that the condition of an
+ if/then/else conditional is a [condexpr]. *)
+
+Inductive stmt : Set :=
+ | Sskip: stmt
+ | Sexpr: expr -> stmt
+ | Sassign : ident -> expr -> stmt
+ | Sseq: stmt -> stmt -> stmt
+ | Sifthenelse: condexpr -> stmt -> stmt -> stmt
+ | Sloop: stmt -> stmt
+ | Sblock: stmt -> stmt
+ | Sexit: nat -> stmt
+ | Sswitch: expr -> list (int * nat) -> nat -> stmt
+ | Sreturn: option expr -> stmt
+ | Stailcall: signature -> expr -> exprlist -> stmt.
+
+Record function : Set := mkfunction {
+ fn_sig: signature;
+ fn_params: list ident;
+ fn_vars: list ident;
+ fn_stackspace: Z;
+ fn_body: stmt
+}.
+
+Definition fundef := AST.fundef function.
+Definition program := AST.program fundef unit.
+
+Definition funsig (fd: fundef) :=
+ match fd with
+ | Internal f => f.(fn_sig)
+ | External ef => ef.(ef_sig)
+ end.
+
+(** * Operational semantics *)
+
+(** Three kinds of evaluation environments are involved:
+- [genv]: global environments, define symbols and functions;
+- [env]: local environments, map local variables to values;
+- [lenv]: let environments, map de Bruijn indices to values.
+*)
+
+Definition genv := Genv.t fundef.
+
+Section RELSEM.
+
+Variable ge: genv.
+
+(** The evaluation predicates have the same general shape as those
+ of Cminor. Refer to the description of Cminor semantics for
+ the meaning of the parameters of the predicates.
+ One additional predicate is introduced:
+ [eval_condexpr ge sp le e m a t m' b], meaning that the conditional
+ expression [a] evaluates to the boolean [b]. *)
+
+Inductive eval_expr:
+ val -> letenv -> env ->
+ mem -> expr -> trace -> mem -> val -> Prop :=
+ | eval_Evar:
+ forall sp le e m id v,
+ PTree.get id e = Some v ->
+ eval_expr sp le e m (Evar id) E0 m v
+ | eval_Eop:
+ forall sp le e m op al t m1 vl v,
+ eval_exprlist sp le e m al t m1 vl ->
+ eval_operation ge sp op vl m1 = Some v ->
+ eval_expr sp le e m (Eop op al) t m1 v
+ | eval_Eload:
+ forall sp le e m chunk addr al t m1 v vl a,
+ eval_exprlist sp le e m al t m1 vl ->
+ eval_addressing ge sp addr vl = Some a ->
+ Mem.loadv chunk m1 a = Some v ->
+ eval_expr sp le e m (Eload chunk addr al) t m1 v
+ | eval_Estore:
+ forall sp le e m chunk addr al b t t1 m1 vl t2 m2 m3 v a,
+ eval_exprlist sp le e m al t1 m1 vl ->
+ eval_expr sp le e m1 b t2 m2 v ->
+ eval_addressing ge sp addr vl = Some a ->
+ Mem.storev chunk m2 a v = Some m3 ->
+ t = t1 ** t2 ->
+ eval_expr sp le e m (Estore chunk addr al b) t m3 v
+ | eval_Ecall:
+ forall sp le e m sig a bl t t1 m1 t2 m2 t3 m3 vf vargs vres f,
+ eval_expr sp le e m a t1 m1 vf ->
+ eval_exprlist sp le e m1 bl t2 m2 vargs ->
+ Genv.find_funct ge vf = Some f ->
+ funsig f = sig ->
+ eval_funcall m2 f vargs t3 m3 vres ->
+ t = t1 ** t2 ** t3 ->
+ eval_expr sp le e m (Ecall sig a bl) t m3 vres
+ | eval_Econdition:
+ forall sp le e m a b c t t1 m1 v1 t2 m2 v2,
+ eval_condexpr sp le e m a t1 m1 v1 ->
+ eval_expr sp le e m1 (if v1 then b else c) t2 m2 v2 ->
+ t = t1 ** t2 ->
+ eval_expr sp le e m (Econdition a b c) t m2 v2
+ | eval_Elet:
+ forall sp le e m a b t t1 m1 v1 t2 m2 v2,
+ eval_expr sp le e m a t1 m1 v1 ->
+ eval_expr sp (v1::le) e m1 b t2 m2 v2 ->
+ t = t1 ** t2 ->
+ eval_expr sp le e m (Elet a b) t m2 v2
+ | eval_Eletvar:
+ forall sp le e m n v,
+ nth_error le n = Some v ->
+ eval_expr sp le e m (Eletvar n) E0 m v
+ | eval_Ealloc:
+ forall sp le e m a t m1 n m2 b,
+ eval_expr sp le e m a t m1 (Vint n) ->
+ Mem.alloc m1 0 (Int.signed n) = (m2, b) ->
+ eval_expr sp le e m (Ealloc a) t m2 (Vptr b Int.zero)
+
+with eval_condexpr:
+ val -> letenv -> env ->
+ mem -> condexpr -> trace -> mem -> bool -> Prop :=
+ | eval_CEtrue:
+ forall sp le e m,
+ eval_condexpr sp le e m CEtrue E0 m true
+ | eval_CEfalse:
+ forall sp le e m,
+ eval_condexpr sp le e m CEfalse E0 m false
+ | eval_CEcond:
+ forall sp le e m cond al t1 m1 vl b,
+ eval_exprlist sp le e m al t1 m1 vl ->
+ eval_condition cond vl m1 = Some b ->
+ eval_condexpr sp le e m (CEcond cond al) t1 m1 b
+ | eval_CEcondition:
+ forall sp le e m a b c t t1 m1 vb1 t2 m2 vb2,
+ eval_condexpr sp le e m a t1 m1 vb1 ->
+ eval_condexpr sp le e m1 (if vb1 then b else c) t2 m2 vb2 ->
+ t = t1 ** t2 ->
+ eval_condexpr sp le e m (CEcondition a b c) t m2 vb2
+
+with eval_exprlist:
+ val -> letenv -> env ->
+ mem -> exprlist -> trace -> mem -> list val -> Prop :=
+ | eval_Enil:
+ forall sp le e m,
+ eval_exprlist sp le e m Enil E0 m nil
+ | eval_Econs:
+ forall sp le e m a bl t t1 m1 v t2 m2 vl,
+ eval_expr sp le e m a t1 m1 v ->
+ eval_exprlist sp le e m1 bl t2 m2 vl ->
+ t = t1 ** t2 ->
+ eval_exprlist sp le e m (Econs a bl) t m2 (v :: vl)
+
+with eval_funcall:
+ mem -> fundef -> list val -> trace ->
+ mem -> val -> Prop :=
+ | eval_funcall_internal:
+ forall m f vargs m1 sp e t e2 m2 out vres,
+ Mem.alloc m 0 f.(fn_stackspace) = (m1, sp) ->
+ set_locals f.(fn_vars) (set_params vargs f.(fn_params)) = e ->
+ exec_stmt (Vptr sp Int.zero) e m1 f.(fn_body) t e2 m2 out ->
+ outcome_result_value out f.(fn_sig).(sig_res) vres ->
+ eval_funcall m (Internal f) vargs t (outcome_free_mem out m2 sp) vres
+ | eval_funcall_external:
+ forall ef m args t res,
+ event_match ef args t res ->
+ eval_funcall m (External ef) args t m res
+
+with exec_stmt:
+ val ->
+ env -> mem -> stmt -> trace ->
+ env -> mem -> outcome -> Prop :=
+ | exec_Sskip:
+ forall sp e m,
+ exec_stmt sp e m Sskip E0 e m Out_normal
+ | exec_Sexpr:
+ forall sp e m a t m1 v,
+ eval_expr sp nil e m a t m1 v ->
+ exec_stmt sp e m (Sexpr a) t e m1 Out_normal
+ | exec_Sassign:
+ forall sp e m id a t m1 v,
+ eval_expr sp nil e m a t m1 v ->
+ exec_stmt sp e m (Sassign id a) t (PTree.set id v e) m1 Out_normal
+ | exec_Sifthenelse:
+ forall sp e m a s1 s2 t t1 m1 v1 t2 e2 m2 out,
+ eval_condexpr sp nil e m a t1 m1 v1 ->
+ exec_stmt sp e m1 (if v1 then s1 else s2) t2 e2 m2 out ->
+ t = t1 ** t2 ->
+ exec_stmt sp e m (Sifthenelse a s1 s2) t e2 m2 out
+ | exec_Sseq_continue:
+ forall sp e m t s1 t1 e1 m1 s2 t2 e2 m2 out,
+ exec_stmt sp e m s1 t1 e1 m1 Out_normal ->
+ exec_stmt sp e1 m1 s2 t2 e2 m2 out ->
+ t = t1 ** t2 ->
+ exec_stmt sp e m (Sseq s1 s2) t e2 m2 out
+ | exec_Sseq_stop:
+ forall sp e m t s1 s2 e1 m1 out,
+ exec_stmt sp e m s1 t e1 m1 out ->
+ out <> Out_normal ->
+ exec_stmt sp e m (Sseq s1 s2) t e1 m1 out
+ | exec_Sloop_loop:
+ forall sp e m s t t1 e1 m1 t2 e2 m2 out,
+ exec_stmt sp e m s t1 e1 m1 Out_normal ->
+ exec_stmt sp e1 m1 (Sloop s) t2 e2 m2 out ->
+ t = t1 ** t2 ->
+ exec_stmt sp e m (Sloop s) t e2 m2 out
+ | exec_Sloop_stop:
+ forall sp e m t s e1 m1 out,
+ exec_stmt sp e m s t e1 m1 out ->
+ out <> Out_normal ->
+ exec_stmt sp e m (Sloop s) t e1 m1 out
+ | exec_Sblock:
+ forall sp e m s t e1 m1 out,
+ exec_stmt sp e m s t e1 m1 out ->
+ exec_stmt sp e m (Sblock s) t e1 m1 (outcome_block out)
+ | exec_Sexit:
+ forall sp e m n,
+ exec_stmt sp e m (Sexit n) E0 e m (Out_exit n)
+ | exec_Sswitch:
+ forall sp e m a cases default t1 m1 n,
+ eval_expr sp nil e m a t1 m1 (Vint n) ->
+ exec_stmt sp e m (Sswitch a cases default)
+ t1 e m1 (Out_exit (switch_target n default cases))
+ | exec_Sreturn_none:
+ forall sp e m,
+ exec_stmt sp e m (Sreturn None) E0 e m (Out_return None)
+ | exec_Sreturn_some:
+ forall sp e m a t m1 v,
+ eval_expr sp nil e m a t m1 v ->
+ exec_stmt sp e m (Sreturn (Some a)) t e m1 (Out_return (Some v))
+ | exec_Stailcall:
+ forall sp e m sig a bl t t1 m1 t2 m2 t3 m3 vf vargs vres f,
+ eval_expr (Vptr sp Int.zero) nil e m a t1 m1 vf ->
+ eval_exprlist (Vptr sp Int.zero) nil e m1 bl t2 m2 vargs ->
+ Genv.find_funct ge vf = Some f ->
+ funsig f = sig ->
+ eval_funcall (Mem.free m2 sp) f vargs t3 m3 vres ->
+ t = t1 ** t2 ** t3 ->
+ exec_stmt (Vptr sp Int.zero) e m (Stailcall sig a bl) t e m3 (Out_tailcall_return vres).
+
+Scheme eval_expr_ind5 := Minimality for eval_expr Sort Prop
+ with eval_condexpr_ind5 := Minimality for eval_condexpr Sort Prop
+ with eval_exprlist_ind5 := Minimality for eval_exprlist Sort Prop
+ with eval_funcall_ind5 := Minimality for eval_funcall Sort Prop
+ with exec_stmt_ind5 := Minimality for exec_stmt Sort Prop.
+
+End RELSEM.
+
+Definition exec_program (p: program) (t: trace) (r: val) : Prop :=
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ exists b, exists f, exists m,
+ Genv.find_symbol ge p.(prog_main) = Some b /\
+ Genv.find_funct_ptr ge b = Some f /\
+ funsig f = mksignature nil (Some Tint) /\
+ eval_funcall ge m0 f nil t m r.
+
diff --git a/backend/Coloring.v b/backend/Coloring.v
index 0b8a4ccc0b96872b99b5a7c4e1176269873d5c74..57f7d5946731b12903b291fa8ac516889095d1ad 100644
--- a/backend/Coloring.v
+++ b/backend/Coloring.v
@@ -150,6 +150,8 @@ Definition add_edges_instr
(add_interf_op res live
(add_interf_call
(Regset.remove res live) destroyed_at_call_regs g)))
+ | Itailcall sig ros args =>
+ add_prefs_call args (loc_arguments sig) g
| Ialloc arg res s =>
add_pref_mreg arg loc_alloc_argument
(add_pref_mreg res loc_alloc_result
diff --git a/backend/Coloringproof.v b/backend/Coloringproof.v
index f3801d079e99930d9d97af574f027a2b90c19278..ce24030de71e05079277d5993696ee78260d12db 100644
--- a/backend/Coloringproof.v
+++ b/backend/Coloringproof.v
@@ -325,6 +325,7 @@ Proof.
eapply graph_incl_trans; [idtac|apply add_pref_mreg_incl].
eapply graph_incl_trans; [idtac|apply add_interf_op_incl].
apply add_interf_call_incl.
+ apply add_prefs_call_incl.
eapply graph_incl_trans; [idtac|apply add_pref_mreg_incl].
eapply graph_incl_trans; [idtac|apply add_pref_mreg_incl].
eapply graph_incl_trans; [idtac|apply add_interf_op_incl].
diff --git a/backend/Constprop.v b/backend/Constprop.v
index d34c6eedcc27bc285128215aa88eab7d69a4e266..fecfb19fc978cdd71cb814c7e720a69ff30a45f1 100644
--- a/backend/Constprop.v
+++ b/backend/Constprop.v
@@ -632,6 +632,8 @@ Definition transfer (f: function) (pc: node) (before: D.t) :=
before
| Icall sig ros args res s =>
D.set res Unknown before
+ | Itailcall sig ros args =>
+ before
| Ialloc arg res s =>
D.set res Unknown before
| Icond cond args ifso ifnot =>
@@ -649,9 +651,12 @@ Definition transfer (f: function) (pc: node) (before: D.t) :=
Module DS := Dataflow_Solver(D)(NodeSetForward).
-Definition analyze (f: RTL.function): option (PMap.t D.t) :=
- DS.fixpoint (successors f) f.(fn_nextpc) (transfer f)
- ((f.(fn_entrypoint), D.top) :: nil).
+Definition analyze (f: RTL.function): PMap.t D.t :=
+ match DS.fixpoint (successors f) f.(fn_nextpc) (transfer f)
+ ((f.(fn_entrypoint), D.top) :: nil) with
+ | None => PMap.init D.top
+ | Some res => res
+ end.
(** * Code transformation *)
@@ -986,6 +991,16 @@ End STRENGTH_REDUCTION.
and similarly for the addressing modes of load and store instructions.
Other instructions are unchanged. *)
+Definition transf_ros (approx: D.t) (ros: reg + ident) : reg + ident :=
+ match ros with
+ | inl r =>
+ match D.get r approx with
+ | S symb ofs => if Int.eq ofs Int.zero then inr _ symb else ros
+ | _ => ros
+ end
+ | inr s => ros
+ end.
+
Definition transf_instr (approx: D.t) (instr: instruction) :=
match instr with
| Iop op args res s =>
@@ -1007,16 +1022,9 @@ Definition transf_instr (approx: D.t) (instr: instruction) :=
let (addr', args') := addr_strength_reduction approx addr args in
Istore chunk addr' args' src s
| Icall sig ros args res s =>
- let ros' :=
- match ros with
- | inl r =>
- match D.get r approx with
- | S symb ofs => if Int.eq ofs Int.zero then inr _ symb else ros
- | _ => ros
- end
- | inr s => ros
- end in
- Icall sig ros' args res s
+ Icall sig (transf_ros approx ros) args res s
+ | Itailcall sig ros args =>
+ Itailcall sig (transf_ros approx ros) args
| Ialloc arg res s =>
Ialloc arg res s
| Icond cond args s1 s2 =>
@@ -1048,20 +1056,18 @@ Proof.
Qed.
Definition transf_function (f: function) : function :=
- match analyze f with
- | None => f
- | Some approxs =>
- mkfunction
- f.(fn_sig)
- f.(fn_params)
- f.(fn_stacksize)
- (transf_code approxs f.(fn_code))
- f.(fn_entrypoint)
- f.(fn_nextpc)
- (transf_code_wf f approxs f.(fn_code_wf))
- end.
+ let approxs := analyze f in
+ mkfunction
+ f.(fn_sig)
+ f.(fn_params)
+ f.(fn_stacksize)
+ (transf_code approxs f.(fn_code))
+ f.(fn_entrypoint)
+ f.(fn_nextpc)
+ (transf_code_wf f approxs f.(fn_code_wf)).
-Definition transf_fundef := AST.transf_fundef transf_function.
+Definition transf_fundef (fd: fundef) : fundef :=
+ AST.transf_fundef transf_function fd.
Definition transf_program (p: program) : program :=
transform_program transf_fundef p.
diff --git a/backend/Constpropproof.v b/backend/Constpropproof.v
index ee24187373b1233ca1ebdfd99fbc1082d3ac665a..dfa828bfe7bfda0f10002afe71d3706df1d88f29 100644
--- a/backend/Constpropproof.v
+++ b/backend/Constpropproof.v
@@ -9,6 +9,7 @@ Require Import Values.
Require Import Events.
Require Import Mem.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Op.
Require Import Registers.
Require Import RTL.
@@ -41,6 +42,13 @@ Definition val_match_approx (a: approx) (v: val) : Prop :=
Definition regs_match_approx (a: D.t) (rs: regset) : Prop :=
forall r, val_match_approx (D.get r a) rs#r.
+Lemma regs_match_approx_top:
+ forall rs, regs_match_approx D.top rs.
+Proof.
+ intros. red; intros. simpl. rewrite PTree.gempty.
+ unfold Approx.top, val_match_approx. auto.
+Qed.
+
Lemma val_match_approx_increasing:
forall a1 a2 v,
Approx.ge a1 a2 -> val_match_approx a2 v -> val_match_approx a1 v.
@@ -123,10 +131,10 @@ Ltac InvVLMA :=
approximations returned by [eval_static_operation]. *)
Lemma eval_static_condition_correct:
- forall cond al vl b,
+ forall cond al vl m b,
val_list_match_approx al vl ->
eval_static_condition cond al = Some b ->
- eval_condition cond vl = Some b.
+ eval_condition cond vl m = Some b.
Proof.
intros until b.
unfold eval_static_condition.
@@ -135,9 +143,9 @@ Proof.
Qed.
Lemma eval_static_operation_correct:
- forall op sp al vl v,
+ forall op sp al vl m v,
val_list_match_approx al vl ->
- eval_operation ge sp op vl = Some v ->
+ eval_operation ge sp op vl m = Some v ->
val_match_approx (eval_static_operation op al) v.
Proof.
intros until v.
@@ -183,7 +191,7 @@ Proof.
rewrite <- H3. replace v0 with (Vfloat n1). reflexivity. congruence.
caseEq (eval_static_condition c vl0).
- intros. generalize (eval_static_condition_correct _ _ _ _ H H1).
+ intros. generalize (eval_static_condition_correct _ _ _ m _ H H1).
intro. rewrite H2 in H0.
destruct b; injection H0; intro; subst v; simpl; auto.
intros; simpl; auto.
@@ -194,80 +202,40 @@ Proof.
auto.
Qed.
-(** The correctness of the transfer function follows: if the register
- state before a transition matches the static approximations at that
- program point, the register state after that transition matches
- the static approximation returned by the transfer function. *)
-
-Lemma transfer_correct:
- forall f c sp pc rs m t pc' rs' m' ra,
- exec_instr ge c sp pc rs m t pc' rs' m' ->
- c = f.(fn_code) ->
- regs_match_approx ra rs ->
- regs_match_approx (transfer f pc ra) rs'.
-Proof.
- induction 1; intros; subst c; unfold transfer; rewrite H; auto.
- (* Iop *)
- apply regs_match_approx_update.
- apply eval_static_operation_correct with sp rs##args.
- eapply approx_regs_val_list. auto. auto. auto.
- (* Iload *)
- apply regs_match_approx_update; auto. simpl; auto.
- (* Icall *)
- apply regs_match_approx_update; auto. simpl; auto.
- (* Ialloc *)
- apply regs_match_approx_update; auto. simpl; auto.
-Qed.
-
(** The correctness of the static analysis follows from the results
above and the fact that the result of the static analysis is
a solution of the forward dataflow inequations. *)
Lemma analyze_correct_1:
- forall f approxs,
- analyze f = Some approxs ->
- forall c sp pc rs m t pc' rs' m',
- exec_instr ge c sp pc rs m t pc' rs' m' ->
- c = f.(fn_code) ->
- regs_match_approx approxs!!pc rs ->
- regs_match_approx approxs!!pc' rs'.
+ forall f pc rs pc',
+ In pc' (successors f pc) ->
+ regs_match_approx (transfer f pc (analyze f)!!pc) rs ->
+ regs_match_approx (analyze f)!!pc' rs.
Proof.
- intros.
+ intros until pc'. unfold analyze.
+ caseEq (DS.fixpoint (successors f) (fn_nextpc f) (transfer f)
+ ((fn_entrypoint f, D.top) :: nil)).
+ intros approxs; intros.
apply regs_match_approx_increasing with (transfer f pc approxs!!pc).
- eapply DS.fixpoint_solution.
- unfold analyze in H. eexact H.
+ eapply DS.fixpoint_solution; eauto.
elim (fn_code_wf f pc); intro. auto.
- generalize (exec_instr_present _ _ _ _ _ _ _ _ _ _ H0).
- rewrite H1. intro. contradiction.
- eapply successors_correct. rewrite <- H1. eauto.
- eapply transfer_correct; eauto.
-Qed.
-
-Lemma analyze_correct_2:
- forall f approxs,
- analyze f = Some approxs ->
- forall c sp pc rs m t pc' rs' m',
- exec_instrs ge c sp pc rs m t pc' rs' m' ->
- c = f.(fn_code) ->
- regs_match_approx approxs!!pc rs ->
- regs_match_approx approxs!!pc' rs'.
-Proof.
- intros f approxs ANL. induction 1.
+ unfold successors in H0; rewrite H2 in H0; simpl; contradiction.
auto.
- intros. eapply analyze_correct_1; eauto.
- eauto.
+ intros. rewrite PMap.gi. apply regs_match_approx_top.
Qed.
Lemma analyze_correct_3:
- forall f approxs rs,
- analyze f = Some approxs ->
- regs_match_approx approxs!!(f.(fn_entrypoint)) rs.
+ forall f rs,
+ regs_match_approx (analyze f)!!(f.(fn_entrypoint)) rs.
Proof.
- intros.
+ intros. unfold analyze.
+ caseEq (DS.fixpoint (successors f) (fn_nextpc f) (transfer f)
+ ((fn_entrypoint f, D.top) :: nil)).
+ intros approxs; intros.
apply regs_match_approx_increasing with D.top.
- eapply DS.fixpoint_entry. unfold analyze in H; eexact H.
- auto with coqlib.
- red; intros. rewrite D.get_top. simpl; auto.
+ eapply DS.fixpoint_entry; eauto. auto with coqlib.
+ apply regs_match_approx_top.
+ intros. rewrite PMap.gi. apply regs_match_approx_top.
Qed.
(** * Correctness of strength reduction *)
@@ -296,9 +264,9 @@ Proof.
Qed.
Lemma cond_strength_reduction_correct:
- forall cond args,
+ forall cond args m,
let (cond', args') := cond_strength_reduction approx cond args in
- eval_condition cond' rs##args' = eval_condition cond rs##args.
+ eval_condition cond' rs##args' m = eval_condition cond rs##args m.
Proof.
intros. unfold cond_strength_reduction.
case (cond_strength_reduction_match cond args); intros.
@@ -312,7 +280,6 @@ Proof.
caseEq (intval approx r1); intros.
simpl. rewrite (intval_correct _ _ H).
destruct (rs#r2); auto. rewrite Int.swap_cmpu. auto.
- destruct c; reflexivity.
caseEq (intval approx r2); intros.
simpl. rewrite (intval_correct _ _ H0). auto.
auto.
@@ -320,10 +287,10 @@ Proof.
Qed.
Lemma make_addimm_correct:
- forall n r v,
+ forall n r m v,
let (op, args) := make_addimm n r in
- eval_operation ge sp Oadd (rs#r :: Vint n :: nil) = Some v ->
- eval_operation ge sp op rs##args = Some v.
+ eval_operation ge sp Oadd (rs#r :: Vint n :: nil) m = Some v ->
+ eval_operation ge sp op rs##args m = Some v.
Proof.
intros; unfold make_addimm.
generalize (Int.eq_spec n Int.zero); case (Int.eq n Int.zero); intros.
@@ -333,10 +300,10 @@ Proof.
Qed.
Lemma make_shlimm_correct:
- forall n r v,
+ forall n r m v,
let (op, args) := make_shlimm n r in
- eval_operation ge sp Oshl (rs#r :: Vint n :: nil) = Some v ->
- eval_operation ge sp op rs##args = Some v.
+ eval_operation ge sp Oshl (rs#r :: Vint n :: nil) m = Some v ->
+ eval_operation ge sp op rs##args m = Some v.
Proof.
intros; unfold make_shlimm.
generalize (Int.eq_spec n Int.zero); case (Int.eq n Int.zero); intros.
@@ -347,10 +314,10 @@ Proof.
Qed.
Lemma make_shrimm_correct:
- forall n r v,
+ forall n r m v,
let (op, args) := make_shrimm n r in
- eval_operation ge sp Oshr (rs#r :: Vint n :: nil) = Some v ->
- eval_operation ge sp op rs##args = Some v.
+ eval_operation ge sp Oshr (rs#r :: Vint n :: nil) m = Some v ->
+ eval_operation ge sp op rs##args m = Some v.
Proof.
intros; unfold make_shrimm.
generalize (Int.eq_spec n Int.zero); case (Int.eq n Int.zero); intros.
@@ -359,10 +326,10 @@ Proof.
Qed.
Lemma make_shruimm_correct:
- forall n r v,
+ forall n r m v,
let (op, args) := make_shruimm n r in
- eval_operation ge sp Oshru (rs#r :: Vint n :: nil) = Some v ->
- eval_operation ge sp op rs##args = Some v.
+ eval_operation ge sp Oshru (rs#r :: Vint n :: nil) m = Some v ->
+ eval_operation ge sp op rs##args m = Some v.
Proof.
intros; unfold make_shruimm.
generalize (Int.eq_spec n Int.zero); case (Int.eq n Int.zero); intros.
@@ -373,10 +340,10 @@ Proof.
Qed.
Lemma make_mulimm_correct:
- forall n r v,
+ forall n r m v,
let (op, args) := make_mulimm n r in
- eval_operation ge sp Omul (rs#r :: Vint n :: nil) = Some v ->
- eval_operation ge sp op rs##args = Some v.
+ eval_operation ge sp Omul (rs#r :: Vint n :: nil) m = Some v ->
+ eval_operation ge sp op rs##args m = Some v.
Proof.
intros; unfold make_mulimm.
generalize (Int.eq_spec n Int.zero); case (Int.eq n Int.zero); intros.
@@ -384,8 +351,8 @@ Proof.
generalize (Int.eq_spec n Int.one); case (Int.eq n Int.one); intros.
subst n. simpl in H1. simpl. FuncInv. rewrite Int.mul_one in H0. congruence.
caseEq (Int.is_power2 n); intros.
- replace (eval_operation ge sp Omul (rs # r :: Vint n :: nil))
- with (eval_operation ge sp Oshl (rs # r :: Vint i :: nil)).
+ replace (eval_operation ge sp Omul (rs # r :: Vint n :: nil) m)
+ with (eval_operation ge sp Oshl (rs # r :: Vint i :: nil) m).
apply make_shlimm_correct.
simpl. generalize (Int.is_power2_range _ _ H1).
change (Z_of_nat wordsize) with 32. intro. rewrite H2.
@@ -394,10 +361,10 @@ Proof.
Qed.
Lemma make_andimm_correct:
- forall n r v,
+ forall n r m v,
let (op, args) := make_andimm n r in
- eval_operation ge sp Oand (rs#r :: Vint n :: nil) = Some v ->
- eval_operation ge sp op rs##args = Some v.
+ eval_operation ge sp Oand (rs#r :: Vint n :: nil) m = Some v ->
+ eval_operation ge sp op rs##args m = Some v.
Proof.
intros; unfold make_andimm.
generalize (Int.eq_spec n Int.zero); case (Int.eq n Int.zero); intros.
@@ -408,10 +375,10 @@ Proof.
Qed.
Lemma make_orimm_correct:
- forall n r v,
+ forall n r m v,
let (op, args) := make_orimm n r in
- eval_operation ge sp Oor (rs#r :: Vint n :: nil) = Some v ->
- eval_operation ge sp op rs##args = Some v.
+ eval_operation ge sp Oor (rs#r :: Vint n :: nil) m = Some v ->
+ eval_operation ge sp op rs##args m = Some v.
Proof.
intros; unfold make_orimm.
generalize (Int.eq_spec n Int.zero); case (Int.eq n Int.zero); intros.
@@ -422,10 +389,10 @@ Proof.
Qed.
Lemma make_xorimm_correct:
- forall n r v,
+ forall n r m v,
let (op, args) := make_xorimm n r in
- eval_operation ge sp Oxor (rs#r :: Vint n :: nil) = Some v ->
- eval_operation ge sp op rs##args = Some v.
+ eval_operation ge sp Oxor (rs#r :: Vint n :: nil) m = Some v ->
+ eval_operation ge sp op rs##args m = Some v.
Proof.
intros; unfold make_xorimm.
generalize (Int.eq_spec n Int.zero); case (Int.eq n Int.zero); intros.
@@ -434,18 +401,18 @@ Proof.
Qed.
Lemma op_strength_reduction_correct:
- forall op args v,
+ forall op args m v,
let (op', args') := op_strength_reduction approx op args in
- eval_operation ge sp op rs##args = Some v ->
- eval_operation ge sp op' rs##args' = Some v.
+ eval_operation ge sp op rs##args m = Some v ->
+ eval_operation ge sp op' rs##args' m = Some v.
Proof.
intros; unfold op_strength_reduction;
case (op_strength_reduction_match op args); intros; simpl List.map.
(* Oadd *)
caseEq (intval approx r1); intros.
rewrite (intval_correct _ _ H).
- replace (eval_operation ge sp Oadd (Vint i :: rs # r2 :: nil))
- with (eval_operation ge sp Oadd (rs # r2 :: Vint i :: nil)).
+ replace (eval_operation ge sp Oadd (Vint i :: rs # r2 :: nil) m)
+ with (eval_operation ge sp Oadd (rs # r2 :: Vint i :: nil) m).
apply make_addimm_correct.
simpl. destruct rs#r2; auto. rewrite Int.add_commut; auto.
caseEq (intval approx r2); intros.
@@ -456,16 +423,16 @@ Proof.
rewrite (intval_correct _ _ H) in H0. assumption.
caseEq (intval approx r2); intros.
rewrite (intval_correct _ _ H0).
- replace (eval_operation ge sp Osub (rs # r1 :: Vint i :: nil))
- with (eval_operation ge sp Oadd (rs # r1 :: Vint (Int.neg i) :: nil)).
+ replace (eval_operation ge sp Osub (rs # r1 :: Vint i :: nil) m)
+ with (eval_operation ge sp Oadd (rs # r1 :: Vint (Int.neg i) :: nil) m).
apply make_addimm_correct.
simpl. destruct rs#r1; auto; rewrite Int.sub_add_opp; auto.
assumption.
(* Omul *)
caseEq (intval approx r1); intros.
rewrite (intval_correct _ _ H).
- replace (eval_operation ge sp Omul (Vint i :: rs # r2 :: nil))
- with (eval_operation ge sp Omul (rs # r2 :: Vint i :: nil)).
+ replace (eval_operation ge sp Omul (Vint i :: rs # r2 :: nil) m)
+ with (eval_operation ge sp Omul (rs # r2 :: Vint i :: nil) m).
apply make_mulimm_correct.
simpl. destruct rs#r2; auto. rewrite Int.mul_commut; auto.
caseEq (intval approx r2); intros.
@@ -485,8 +452,8 @@ Proof.
caseEq (intval approx r2); intros.
caseEq (Int.is_power2 i); intros.
rewrite (intval_correct _ _ H).
- replace (eval_operation ge sp Odivu (rs # r1 :: Vint i :: nil))
- with (eval_operation ge sp Oshru (rs # r1 :: Vint i0 :: nil)).
+ replace (eval_operation ge sp Odivu (rs # r1 :: Vint i :: nil) m)
+ with (eval_operation ge sp Oshru (rs # r1 :: Vint i0 :: nil) m).
apply make_shruimm_correct.
simpl. destruct rs#r1; auto.
change 32 with (Z_of_nat wordsize).
@@ -499,8 +466,8 @@ Proof.
(* Oand *)
caseEq (intval approx r1); intros.
rewrite (intval_correct _ _ H).
- replace (eval_operation ge sp Oand (Vint i :: rs # r2 :: nil))
- with (eval_operation ge sp Oand (rs # r2 :: Vint i :: nil)).
+ replace (eval_operation ge sp Oand (Vint i :: rs # r2 :: nil) m)
+ with (eval_operation ge sp Oand (rs # r2 :: Vint i :: nil) m).
apply make_andimm_correct.
simpl. destruct rs#r2; auto. rewrite Int.and_commut; auto.
caseEq (intval approx r2); intros.
@@ -509,8 +476,8 @@ Proof.
(* Oor *)
caseEq (intval approx r1); intros.
rewrite (intval_correct _ _ H).
- replace (eval_operation ge sp Oor (Vint i :: rs # r2 :: nil))
- with (eval_operation ge sp Oor (rs # r2 :: Vint i :: nil)).
+ replace (eval_operation ge sp Oor (Vint i :: rs # r2 :: nil) m)
+ with (eval_operation ge sp Oor (rs # r2 :: Vint i :: nil) m).
apply make_orimm_correct.
simpl. destruct rs#r2; auto. rewrite Int.or_commut; auto.
caseEq (intval approx r2); intros.
@@ -519,8 +486,8 @@ Proof.
(* Oxor *)
caseEq (intval approx r1); intros.
rewrite (intval_correct _ _ H).
- replace (eval_operation ge sp Oxor (Vint i :: rs # r2 :: nil))
- with (eval_operation ge sp Oxor (rs # r2 :: Vint i :: nil)).
+ replace (eval_operation ge sp Oxor (Vint i :: rs # r2 :: nil) m)
+ with (eval_operation ge sp Oxor (rs # r2 :: Vint i :: nil) m).
apply make_xorimm_correct.
simpl. destruct rs#r2; auto. rewrite Int.xor_commut; auto.
caseEq (intval approx r2); intros.
@@ -647,261 +614,329 @@ Let tge := Genv.globalenv tprog.
Lemma symbols_preserved:
forall (s: ident), Genv.find_symbol tge s = Genv.find_symbol ge s.
-Proof (Genv.find_symbol_transf transf_fundef prog).
+Proof.
+ intros; unfold ge, tge, tprog, transf_program.
+ apply Genv.find_symbol_transf.
+Qed.
Lemma functions_translated:
- forall (v: val) (f: RTL.fundef),
+ forall (v: val) (f: fundef),
Genv.find_funct ge v = Some f ->
Genv.find_funct tge v = Some (transf_fundef f).
-Proof (@Genv.find_funct_transf _ _ _ transf_fundef prog).
+Proof.
+ intros.
+ exact (Genv.find_funct_transf transf_fundef H).
+Qed.
Lemma function_ptr_translated:
- forall (v: block) (f: RTL.fundef),
- Genv.find_funct_ptr ge v = Some f ->
- Genv.find_funct_ptr tge v = Some (transf_fundef f).
-Proof (@Genv.find_funct_ptr_transf _ _ _ transf_fundef prog).
+ forall (b: block) (f: fundef),
+ Genv.find_funct_ptr ge b = Some f ->
+ Genv.find_funct_ptr tge b = Some (transf_fundef f).
+Proof.
+ intros.
+ exact (Genv.find_funct_ptr_transf transf_fundef H).
+Qed.
-Lemma sig_translated:
- forall (f: RTL.fundef),
+Lemma sig_function_translated:
+ forall f,
funsig (transf_fundef f) = funsig f.
Proof.
- intro. case f; intros; simpl.
- unfold transf_function. case (analyze f0); intros; reflexivity.
- reflexivity.
+ intros. destruct f; reflexivity.
+Qed.
+
+Lemma transf_ros_correct:
+ forall ros rs f approx,
+ regs_match_approx ge approx rs ->
+ find_function ge ros rs = Some f ->
+ find_function tge (transf_ros approx ros) rs = Some (transf_fundef f).
+Proof.
+ intros until approx; intro MATCH.
+ destruct ros; simpl.
+ intro.
+ exploit functions_translated; eauto. intro FIND.
+ caseEq (D.get r approx); intros; auto.
+ generalize (Int.eq_spec i0 Int.zero); case (Int.eq i0 Int.zero); intros; auto.
+ generalize (MATCH r). rewrite H0. intros [b [A B]].
+ rewrite <- symbols_preserved in A.
+ rewrite B in FIND. rewrite H1 in FIND.
+ rewrite Genv.find_funct_find_funct_ptr in FIND.
+ simpl. rewrite A. auto.
+ rewrite symbols_preserved. destruct (Genv.find_symbol ge i).
+ intro. apply function_ptr_translated. auto.
+ congruence.
Qed.
(** The proof of semantic preservation is a simulation argument
based on diagrams of the following form:
<<
- pc, rs, m ------------------- pc, rs, m
- | |
- | |
- v v
- pc', rs', m' ---------------- pc', rs', m'
+ st1 --------------- st2
+ | |
+ t| |t
+ | |
+ v v
+ st1'--------------- st2'
>>
The left vertical arrow represents a transition in the
- original RTL code. The top horizontal bar expresses that the values
- of registers [rs] match their compile-time approximations at point [pc].
+ original RTL code. The top horizontal bar is the [match_states]
+ invariant between the initial state [st1] in the original RTL code
+ and an initial state [st2] in the transformed code.
+ This invariant expresses that all code fragments appearing in [st2]
+ are obtained by [transf_code] transformation of the corresponding
+ fragments in [st1]. Moreover, the values of registers in [st1]
+ must match their compile-time approximations at the current program
+ point.
These two parts of the diagram are the hypotheses. In conclusions,
we want to prove the other two parts: the right vertical arrow,
which is a transition in the transformed RTL code, and the bottom
- horizontal bar, which means that [rs'] matches the compile-time
- approximations at [pc'].
-
- To help express those diagrams, we define the following propositions
- parameterized by the transition in the original RTL code (left arrow)
- and summarizing the three other arrows of the diagram. *)
-
-Definition exec_instr_prop
- (c: code) (sp: val)
- (pc: node) (rs: regset) (m: mem) (t: trace)
- (pc': node) (rs': regset) (m': mem) : Prop :=
- exec_instr tge c sp pc rs m t pc' rs' m' /\
- forall f approxs
- (CF: c = f.(RTL.fn_code))
- (ANL: analyze f = Some approxs)
- (MATCH: regs_match_approx ge approxs!!pc rs),
- exec_instr tge (transf_code approxs c) sp pc rs m t pc' rs' m'.
-
-Definition exec_instrs_prop
- (c: code) (sp: val)
- (pc: node) (rs: regset) (m: mem) (t: trace)
- (pc': node) (rs': regset) (m': mem) : Prop :=
- exec_instrs tge c sp pc rs m t pc' rs' m' /\
- forall f approxs
- (CF: c = f.(RTL.fn_code))
- (ANL: analyze f = Some approxs)
- (MATCH: regs_match_approx ge approxs!!pc rs),
- exec_instrs tge (transf_code approxs c) sp pc rs m t pc' rs' m'.
-
-Definition exec_function_prop
- (f: RTL.fundef) (args: list val) (m: mem) (t: trace)
- (res: val) (m': mem) : Prop :=
- exec_function tge (transf_fundef f) args m t res m'.
+ horizontal bar, which means that the [match_state] predicate holds
+ between the final states [st1'] and [st2']. *)
+
+Inductive match_stackframes: stackframe -> stackframe -> Prop :=
+ match_stackframe_intro:
+ forall res c sp pc rs f,
+ c = f.(RTL.fn_code) ->
+ (forall v, regs_match_approx ge (analyze f)!!pc (rs#res <- v)) ->
+ match_stackframes
+ (Stackframe res c sp pc rs)
+ (Stackframe res (transf_code (analyze f) c) sp pc rs).
+
+Inductive match_states: state -> state -> Prop :=
+ | match_states_intro:
+ forall s c sp pc rs m f s'
+ (CF: c = f.(RTL.fn_code))
+ (MATCH: regs_match_approx ge (analyze f)!!pc rs)
+ (STACKS: list_forall2 match_stackframes s s'),
+ match_states (State s c sp pc rs m)
+ (State s' (transf_code (analyze f) c) sp pc rs m)
+ | match_states_call:
+ forall s f args m s',
+ list_forall2 match_stackframes s s' ->
+ match_states (Callstate s f args m)
+ (Callstate s' (transf_fundef f) args m)
+ | match_states_return:
+ forall s s' v m,
+ list_forall2 match_stackframes s s' ->
+ match_states (Returnstate s v m)
+ (Returnstate s' v m).
Ltac TransfInstr :=
match goal with
- | H1: (PTree.get ?pc ?c = Some ?instr),
- H2: (analyze ?f = Some ?approxs) |- _ =>
- cut ((transf_code approxs c)!pc = Some(transf_instr approxs!!pc instr));
+ | H1: (PTree.get ?pc ?c = Some ?instr), f: function |- _ =>
+ cut ((transf_code (analyze f) c)!pc = Some(transf_instr (analyze f)!!pc instr));
[ simpl
| unfold transf_code; rewrite PTree.gmap;
unfold option_map; rewrite H1; reflexivity ]
end.
-(** The predicates above serve as induction hypotheses in the proof of
- simulation, which proceeds by induction over the
- evaluation derivation of the original code. *)
+(** The proof of simulation proceeds by case analysis on the transition
+ taken in the source code. *)
-Lemma transf_funct_correct:
- forall f args m t res m',
- exec_function ge f args m t res m' ->
- exec_function_prop f args m t res m'.
+Lemma transf_step_correct:
+ forall s1 t s2,
+ step ge s1 t s2 ->
+ forall s1' (MS: match_states s1 s1'),
+ exists s2', step tge s1' t s2' /\ match_states s2 s2'.
Proof.
- apply (exec_function_ind_3 ge
- exec_instr_prop exec_instrs_prop exec_function_prop);
- intros; red.
+ induction 1; intros; inv MS.
+
(* Inop *)
- split; [idtac| intros; TransfInstr].
- apply exec_Inop; auto.
- intros; apply exec_Inop; auto.
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' rs m); split.
+ TransfInstr; intro. eapply exec_Inop; eauto.
+ econstructor; eauto.
+ eapply analyze_correct_1 with (pc := pc); eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H. auto.
+
(* Iop *)
- split; [idtac| intros; TransfInstr].
- apply exec_Iop with op args. auto.
- rewrite (eval_operation_preserved symbols_preserved). auto.
- caseEq (op_strength_reduction approxs!!pc op args);
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' (rs#res <- v) m); split.
+ TransfInstr. caseEq (op_strength_reduction (analyze f)!!pc op args);
intros op' args' OSR.
- assert (eval_operation tge sp op' rs##args' = Some v).
+ assert (eval_operation tge sp op' rs##args' m = Some v).
rewrite (eval_operation_preserved symbols_preserved).
- generalize (op_strength_reduction_correct ge approxs!!pc sp rs
- MATCH op args v).
+ generalize (op_strength_reduction_correct ge (analyze f)!!pc sp rs
+ MATCH op args m v).
rewrite OSR; simpl. auto.
generalize (eval_static_operation_correct ge op sp
- (approx_regs args approxs!!pc) rs##args v
+ (approx_regs args (analyze f)!!pc) rs##args m v
(approx_regs_val_list _ _ _ args MATCH) H0).
- case (eval_static_operation op (approx_regs args approxs!!pc)); intros;
- simpl in H1;
+ case (eval_static_operation op (approx_regs args (analyze f)!!pc)); intros;
+ simpl in H2;
eapply exec_Iop; eauto; simpl.
- simpl in H2; congruence.
- simpl in H2; congruence.
+ congruence.
+ congruence.
elim H2; intros b [A B]. rewrite symbols_preserved.
rewrite A; rewrite B; auto.
+ econstructor; eauto.
+ eapply analyze_correct_1 with (pc := pc); eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H.
+ apply regs_match_approx_update; auto.
+ eapply eval_static_operation_correct; eauto.
+ apply approx_regs_val_list; auto.
+
(* Iload *)
- split; [idtac| intros; TransfInstr].
- eapply exec_Iload; eauto.
- rewrite (eval_addressing_preserved symbols_preserved). auto.
- caseEq (addr_strength_reduction approxs!!pc addr args);
+ caseEq (addr_strength_reduction (analyze f)!!pc addr args);
intros addr' args' ASR.
assert (eval_addressing tge sp addr' rs##args' = Some a).
rewrite (eval_addressing_preserved symbols_preserved).
- generalize (addr_strength_reduction_correct ge approxs!!pc sp rs
+ generalize (addr_strength_reduction_correct ge (analyze f)!!pc sp rs
MATCH addr args).
rewrite ASR; simpl. congruence.
- intro. eapply exec_Iload; eauto.
+ TransfInstr. rewrite ASR. intro.
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' (rs#dst <- v) m); split.
+ eapply exec_Iload; eauto.
+ econstructor; eauto.
+ apply analyze_correct_1 with pc; auto.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H.
+ apply regs_match_approx_update; auto. simpl; auto.
+
(* Istore *)
- split; [idtac| intros; TransfInstr].
- eapply exec_Istore; eauto.
- rewrite (eval_addressing_preserved symbols_preserved). auto.
- caseEq (addr_strength_reduction approxs!!pc addr args);
+ caseEq (addr_strength_reduction (analyze f)!!pc addr args);
intros addr' args' ASR.
assert (eval_addressing tge sp addr' rs##args' = Some a).
rewrite (eval_addressing_preserved symbols_preserved).
- generalize (addr_strength_reduction_correct ge approxs!!pc sp rs
+ generalize (addr_strength_reduction_correct ge (analyze f)!!pc sp rs
MATCH addr args).
- rewrite ASR; simpl. congruence.
- intro. eapply exec_Istore; eauto.
+ rewrite ASR; simpl. congruence.
+ TransfInstr. rewrite ASR. intro.
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' rs m'); split.
+ eapply exec_Istore; eauto.
+ econstructor; eauto.
+ apply analyze_correct_1 with pc; auto.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H. auto.
+
(* Icall *)
- assert (find_function tge ros rs = Some (transf_fundef f)).
- generalize H0; unfold find_function; destruct ros.
- apply functions_translated.
- rewrite symbols_preserved. destruct (Genv.find_symbol ge i).
- apply function_ptr_translated. congruence.
- assert (funsig (transf_fundef f) = sig).
- generalize (sig_translated f). congruence.
- split; [idtac| intros; TransfInstr].
- eapply exec_Icall; eauto.
- set (ros' :=
- match ros with
- | inl r =>
- match D.get r approxs !! pc with
- | Novalue => ros
- | Unknown => ros
- | I _ => ros
- | F _ => ros
- | S symb ofs => if Int.eq ofs Int.zero then inr reg symb else ros
- end
- | inr _ => ros
- end).
- intros; eapply exec_Icall; eauto.
- unfold ros'; destruct ros; auto.
- caseEq (D.get r approxs!!pc); intros; auto.
- generalize (Int.eq_spec i0 Int.zero); case (Int.eq i0 Int.zero); intros; auto.
- generalize (MATCH r). rewrite H7. intros [b [A B]].
- rewrite <- symbols_preserved in A.
- generalize H4. simpl. rewrite A. rewrite B. subst i0.
- rewrite Genv.find_funct_find_funct_ptr. auto.
+ exploit transf_ros_correct; eauto. intro FIND'.
+ TransfInstr; intro.
+ econstructor; split.
+ eapply exec_Icall; eauto. apply sig_function_translated; auto.
+ constructor; auto. constructor; auto.
+ econstructor; eauto.
+ intros. apply analyze_correct_1 with pc; auto.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H.
+ apply regs_match_approx_update; auto. simpl. auto.
+
+ (* Itailcall *)
+ exploit transf_ros_correct; eauto. intros FIND'.
+ TransfInstr; intro.
+ econstructor; split.
+ eapply exec_Itailcall; eauto. apply sig_function_translated; auto.
+ constructor; auto.
(* Ialloc *)
- split; [idtac|intros; TransfInstr].
- eapply exec_Ialloc; eauto.
- intros. eapply exec_Ialloc; eauto.
+ TransfInstr; intro.
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp pc' (rs#res <- (Vptr b Int.zero)) m'); split.
+ eapply exec_Ialloc; eauto.
+ econstructor; eauto.
+ apply analyze_correct_1 with pc; auto.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H.
+ apply regs_match_approx_update; auto. simpl; auto.
(* Icond, true *)
- split; [idtac| intros; TransfInstr].
- eapply exec_Icond_true; eauto.
- caseEq (cond_strength_reduction approxs!!pc cond args);
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp ifso rs m); split.
+ caseEq (cond_strength_reduction (analyze f)!!pc cond args);
intros cond' args' CSR.
- assert (eval_condition cond' rs##args' = Some true).
+ assert (eval_condition cond' rs##args' m = Some true).
generalize (cond_strength_reduction_correct
- ge approxs!!pc rs MATCH cond args).
+ ge (analyze f)!!pc rs MATCH cond args m).
rewrite CSR. intro. congruence.
- caseEq (eval_static_condition cond (approx_regs args approxs!!pc)).
+ TransfInstr. rewrite CSR.
+ caseEq (eval_static_condition cond (approx_regs args (analyze f)!!pc)).
intros b ESC.
- generalize (eval_static_condition_correct ge cond _ _ _
+ generalize (eval_static_condition_correct ge cond _ _ m _
(approx_regs_val_list _ _ _ args MATCH) ESC); intro.
replace b with true. intro; eapply exec_Inop; eauto. congruence.
- intros. eapply exec_Icond_true; eauto.
+ intros. eapply exec_Icond_true; eauto.
+ econstructor; eauto.
+ apply analyze_correct_1 with pc; auto.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H; auto.
(* Icond, false *)
- split; [idtac| intros; TransfInstr].
- eapply exec_Icond_false; eauto.
- caseEq (cond_strength_reduction approxs!!pc cond args);
+ exists (State s' (transf_code (analyze f) (fn_code f)) sp ifnot rs m); split.
+ caseEq (cond_strength_reduction (analyze f)!!pc cond args);
intros cond' args' CSR.
- assert (eval_condition cond' rs##args' = Some false).
+ assert (eval_condition cond' rs##args' m = Some false).
generalize (cond_strength_reduction_correct
- ge approxs!!pc rs MATCH cond args).
+ ge (analyze f)!!pc rs MATCH cond args m).
rewrite CSR. intro. congruence.
- caseEq (eval_static_condition cond (approx_regs args approxs!!pc)).
+ TransfInstr. rewrite CSR.
+ caseEq (eval_static_condition cond (approx_regs args (analyze f)!!pc)).
intros b ESC.
- generalize (eval_static_condition_correct ge cond _ _ _
+ generalize (eval_static_condition_correct ge cond _ _ m _
(approx_regs_val_list _ _ _ args MATCH) ESC); intro.
replace b with false. intro; eapply exec_Inop; eauto. congruence.
- intros. eapply exec_Icond_false; eauto.
-
- (* refl *)
- split. apply exec_refl. intros. apply exec_refl.
- (* one *)
- elim H0; intros.
- split. apply exec_one; auto.
- intros. apply exec_one. eapply H2; eauto.
- (* trans *)
- elim H0; intros. elim H2; intros.
- split.
- apply exec_trans with t1 pc2 rs2 m2 t2; auto.
- intros; apply exec_trans with t1 pc2 rs2 m2 t2.
- eapply H5; eauto. eapply H7; eauto.
- eapply analyze_correct_2; eauto. auto.
+ intros. eapply exec_Icond_false; eauto.
+ econstructor; eauto.
+ apply analyze_correct_1 with pc; auto.
+ unfold successors; rewrite H; auto with coqlib.
+ unfold transfer; rewrite H; auto.
+
+ (* Ireturn *)
+ exists (Returnstate s' (regmap_optget or Vundef rs) (free m stk)); split.
+ eapply exec_Ireturn; eauto. TransfInstr; auto.
+ constructor; auto.
(* internal function *)
- elim H1; intros.
- simpl. unfold transf_function.
- caseEq (analyze f).
- intros approxs ANL.
- eapply exec_funct_internal; simpl; eauto.
- eapply H5. reflexivity. auto.
+ simpl. unfold transf_function.
+ econstructor; split.
+ eapply exec_function_internal; simpl; eauto.
+ simpl. econstructor; eauto.
apply analyze_correct_3; auto.
- TransfInstr; auto.
- intros. eapply exec_funct_internal; eauto.
+
(* external function *)
- unfold transf_function; simpl. apply exec_funct_external; auto.
+ simpl. econstructor; split.
+ eapply exec_function_external; eauto.
+ constructor; auto.
+
+ (* return *)
+ inv H3. inv H1.
+ econstructor; split.
+ eapply exec_return; eauto.
+ econstructor; eauto.
+Qed.
+
+Lemma transf_initial_states:
+ forall st1, initial_state prog st1 ->
+ exists st2, initial_state tprog st2 /\ match_states st1 st2.
+Proof.
+ intros. inversion H.
+ exploit function_ptr_translated; eauto. intro FIND.
+ exists (Callstate nil (transf_fundef f) nil (Genv.init_mem tprog)); split.
+ econstructor; eauto.
+ replace (prog_main tprog) with (prog_main prog).
+ rewrite symbols_preserved. eauto.
+ reflexivity.
+ rewrite <- H2. apply sig_function_translated.
+ replace (Genv.init_mem tprog) with (Genv.init_mem prog).
+ constructor. constructor. auto.
+ symmetry. unfold tprog, transf_program. apply Genv.init_mem_transf.
+Qed.
+
+Lemma transf_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 -> final_state st1 r -> final_state st2 r.
+Proof.
+ intros. inv H0. inv H. inv H4. constructor.
Qed.
(** The preservation of the observable behavior of the program then
- follows. *)
+ follows, using the generic preservation theorem
+ [Smallstep.simulation_step_preservation]. *)
Theorem transf_program_correct:
- forall (t: trace) (r: val),
- exec_program prog t r -> exec_program tprog t r.
+ forall (beh: program_behavior),
+ exec_program prog beh -> exec_program tprog beh.
Proof.
- intros t r [b [f [m [SYMB [FIND [SIG EXEC]]]]]].
- red. exists b. exists (transf_fundef f). exists m.
- split. change (prog_main tprog) with (prog_main prog).
- rewrite symbols_preserved. auto.
- split. apply function_ptr_translated; auto.
- split. generalize (sig_translated f). congruence.
- apply transf_funct_correct.
- unfold tprog, transf_program. rewrite Genv.init_mem_transf.
- exact EXEC.
+ unfold exec_program; intros.
+ eapply simulation_step_preservation; eauto.
+ eexact transf_initial_states.
+ eexact transf_final_states.
+ exact transf_step_correct.
Qed.
End PRESERVATION.
diff --git a/backend/Conventions.v b/backend/Conventions.v
index d621e7c0243941b4d5a7a53c8c83b237924b67d2..9d005b3475507ac08787687562257c3d1b9b9dca 100644
--- a/backend/Conventions.v
+++ b/backend/Conventions.v
@@ -247,6 +247,31 @@ Proof.
apply temporaries_not_acceptable. auto.
Qed.
+Lemma loc_acceptable_noteq_diff:
+ forall l1 l2,
+ loc_acceptable l1 -> l1 <> l2 -> Loc.diff l1 l2.
+Proof.
+ unfold loc_acceptable, Loc.diff; destruct l1; destruct l2;
+ try (destruct s); try (destruct s0); intros; auto; try congruence.
+ case (zeq z z0); intro.
+ compare t t0; intro.
+ subst z0; subst t0; tauto.
+ tauto. tauto.
+ contradiction. contradiction.
+Qed.
+
+Lemma loc_acceptable_notin_notin:
+ forall r ll,
+ loc_acceptable r ->
+ ~(In r ll) -> Loc.notin r ll.
+Proof.
+ induction ll; simpl; intros.
+ auto.
+ split. apply loc_acceptable_noteq_diff. assumption.
+ apply sym_not_equal. tauto.
+ apply IHll. assumption. tauto.
+Qed.
+
(** * Function calling conventions *)
(** The functions in this section determine the locations (machine registers
@@ -292,9 +317,20 @@ Proof.
reflexivity.
Qed.
-(** The result location is a caller-save register. *)
+(** The result location is acceptable. *)
Lemma loc_result_acceptable:
+ forall sig, loc_acceptable (R (loc_result sig)).
+Proof.
+ intros. unfold loc_acceptable. red.
+ unfold loc_result. destruct (sig_res sig).
+ destruct t; simpl; NotOrEq.
+ simpl; NotOrEq.
+Qed.
+
+(** The result location is a caller-save register. *)
+
+Lemma loc_result_caller_save:
forall (s: signature), In (R (loc_result s)) destroyed_at_call.
Proof.
intros; unfold loc_result.
@@ -309,7 +345,7 @@ Lemma loc_result_not_callee_save:
forall (s: signature),
~(In (loc_result s) int_callee_save_regs \/ In (loc_result s) float_callee_save_regs).
Proof.
- intros. generalize (loc_result_acceptable s).
+ intros. generalize (loc_result_caller_save s).
generalize (int_callee_save_not_destroyed (loc_result s)).
generalize (float_callee_save_not_destroyed (loc_result s)).
tauto.
@@ -340,16 +376,18 @@ Fixpoint loc_arguments_rec
| nil => nil
| Tint :: tys =>
match iregl with
- | nil => S (Outgoing ofs Tint)
- | ireg :: _ => R ireg
- end ::
- loc_arguments_rec tys (list_drop1 iregl) fregl (ofs + 1)
+ | nil =>
+ S (Outgoing ofs Tint) :: loc_arguments_rec tys nil fregl (ofs + 1)
+ | ireg :: iregs =>
+ R ireg :: loc_arguments_rec tys iregs fregl ofs
+ end
| Tfloat :: tys =>
match fregl with
- | nil => S (Outgoing ofs Tfloat)
- | freg :: _ => R freg
- end ::
- loc_arguments_rec tys (list_drop2 iregl) (list_drop1 fregl) (ofs + 2)
+ | nil =>
+ S (Outgoing ofs Tfloat) :: loc_arguments_rec tys iregl nil (ofs + 2)
+ | freg :: fregs =>
+ R freg :: loc_arguments_rec tys (list_drop2 iregl) fregs ofs
+ end
end.
Definition int_param_regs :=
@@ -361,28 +399,45 @@ Definition float_param_regs :=
when calling a function with signature [s]. *)
Definition loc_arguments (s: signature) : list loc :=
- loc_arguments_rec s.(sig_args) int_param_regs float_param_regs 6.
+ loc_arguments_rec s.(sig_args) int_param_regs float_param_regs 14.
(** [size_arguments s] returns the number of [Outgoing] slots used
to call a function with signature [s]. *)
-Fixpoint size_arguments_rec (tyl: list typ) : Z :=
+Fixpoint size_arguments_rec
+ (tyl: list typ) (iregl: list mreg) (fregl: list mreg)
+ (ofs: Z) {struct tyl} : Z :=
match tyl with
- | nil => 6
- | Tint :: tys => 1 + size_arguments_rec tys
- | Tfloat :: tys => 2 + size_arguments_rec tys
+ | nil => ofs
+ | Tint :: tys =>
+ match iregl with
+ | nil => size_arguments_rec tys nil fregl (ofs + 1)
+ | ireg :: iregs => size_arguments_rec tys iregs fregl ofs
+ end
+ | Tfloat :: tys =>
+ match fregl with
+ | nil => size_arguments_rec tys iregl nil (ofs + 2)
+ | freg :: fregs => size_arguments_rec tys (list_drop2 iregl) fregs ofs
+ end
end.
Definition size_arguments (s: signature) : Z :=
- size_arguments_rec s.(sig_args).
+ size_arguments_rec s.(sig_args) int_param_regs float_param_regs 14.
+
+(** A tail-call is possible for a signature if the corresponding
+ arguments are all passed in registers. *)
+
+Definition tailcall_possible (s: signature) : Prop :=
+ forall l, In l (loc_arguments s) ->
+ match l with R _ => True | S _ => False end.
(** Argument locations are either non-temporary registers or [Outgoing]
- stack slots at offset 6 or more. *)
+ stack slots at offset 14 or more. *)
Definition loc_argument_acceptable (l: loc) : Prop :=
match l with
| R r => ~(In l temporaries)
- | S (Outgoing ofs ty) => ofs >= 6
+ | S (Outgoing ofs ty) => ofs >= 14
| _ => False
end.
@@ -397,16 +452,18 @@ Remark loc_arguments_rec_charact:
Proof.
induction tyl; simpl loc_arguments_rec; intros.
elim H.
- destruct a; elim H; intros.
- destruct iregl; subst l. omega. left; auto with coqlib.
- generalize (IHtyl _ _ _ _ H0).
- destruct l. intros [A|B]. left; apply list_drop1_incl; auto. tauto.
- destruct s; try contradiction. omega.
- destruct fregl; subst l. omega. right; auto with coqlib.
- generalize (IHtyl _ _ _ _ H0).
- destruct l. intros [A|B]. left; apply list_drop2_incl; auto.
- right; apply list_drop1_incl; auto.
- destruct s; try contradiction. omega.
+ destruct a.
+ destruct iregl; elim H; intro.
+ subst l. omega.
+ generalize (IHtyl _ _ _ _ H0). destruct l; auto. destruct s; auto. omega.
+ subst l. auto with coqlib.
+ generalize (IHtyl _ _ _ _ H0). destruct l; auto. simpl; intuition.
+ destruct fregl; elim H; intro.
+ subst l. omega.
+ generalize (IHtyl _ _ _ _ H0). destruct l; auto. destruct s; auto. omega.
+ subst l. auto with coqlib.
+ generalize (IHtyl _ _ _ _ H0). destruct l; auto.
+ intros [A|B]. left; apply list_drop2_incl; auto. right; auto with coqlib.
Qed.
Lemma loc_arguments_acceptable:
@@ -432,12 +489,15 @@ Remark loc_arguments_rec_notin_reg:
Proof.
induction tyl; simpl; intros.
auto.
- destruct a; simpl; split.
- destruct iregl. auto. red; intro; subst m. apply H. auto with coqlib.
- apply IHtyl. red; intro. apply H. apply list_drop1_incl; auto. auto.
- destruct fregl. auto. red; intro; subst m. apply H0. auto with coqlib.
- apply IHtyl. red; intro. apply H. apply list_drop2_incl; auto.
- red; intro. apply H0. apply list_drop1_incl; auto.
+ destruct a.
+ destruct iregl; simpl. auto.
+ simpl in H. split. apply sym_not_equal. tauto.
+ apply IHtyl. tauto. tauto.
+ destruct fregl; simpl. auto.
+ simpl in H0. split. apply sym_not_equal. tauto.
+ apply IHtyl.
+ red; intro. apply H. apply list_drop2_incl. auto.
+ tauto.
Qed.
Remark loc_arguments_rec_notin_local:
@@ -446,11 +506,9 @@ Remark loc_arguments_rec_notin_local:
Proof.
induction tyl; simpl; intros.
auto.
- destruct a; simpl; split.
- destruct iregl. auto. auto.
- apply IHtyl.
- destruct fregl. auto. auto.
- apply IHtyl.
+ destruct a.
+ destruct iregl; simpl; auto.
+ destruct fregl; simpl; auto.
Qed.
Remark loc_arguments_rec_notin_outgoing:
@@ -460,11 +518,13 @@ Remark loc_arguments_rec_notin_outgoing:
Proof.
induction tyl; simpl; intros.
auto.
- destruct a; simpl; split.
- destruct iregl. omega. auto.
- apply IHtyl. omega.
- destruct fregl. omega. auto.
- apply IHtyl. omega.
+ destruct a.
+ destruct iregl; simpl.
+ split. omega. eapply IHtyl. omega.
+ auto.
+ destruct fregl; simpl.
+ split. omega. eapply IHtyl. omega.
+ auto.
Qed.
Lemma loc_arguments_norepet:
@@ -477,21 +537,21 @@ Proof.
Loc.norepet (loc_arguments_rec tyl iregl fregl ofs)).
induction tyl; simpl; intros.
constructor.
- destruct a; constructor.
- destruct iregl.
- apply loc_arguments_rec_notin_outgoing. simpl; omega.
- apply loc_arguments_rec_notin_reg. simpl. inversion H. auto.
+ destruct a.
+ destruct iregl; constructor.
+ apply loc_arguments_rec_notin_outgoing. simpl; omega. auto.
+ apply loc_arguments_rec_notin_reg. inversion H. auto.
apply list_disjoint_notin with (m :: iregl); auto with coqlib.
- apply IHtyl. apply list_drop1_norepet; auto. auto.
- red; intros. apply H1. apply list_drop1_incl; auto. auto.
- destruct fregl.
- apply loc_arguments_rec_notin_outgoing. simpl; omega.
- apply loc_arguments_rec_notin_reg. simpl.
+ apply IHtyl. inv H; auto. auto.
+ eapply list_disjoint_cons_left; eauto.
+ destruct fregl; constructor.
+ apply loc_arguments_rec_notin_outgoing. simpl; omega. auto.
+ apply loc_arguments_rec_notin_reg.
red; intro. apply (H1 m m). apply list_drop2_incl; auto.
- auto with coqlib. auto.
- simpl. inversion H0. auto.
- apply IHtyl. apply list_drop2_norepet; auto. apply list_drop1_norepet; auto.
- red; intros. apply H1. apply list_drop2_incl; auto. apply list_drop1_incl; auto.
+ auto with coqlib. auto. inv H0; auto.
+ apply IHtyl. apply list_drop2_norepet; auto.
+ inv H0; auto.
+ red; intros. apply H1. apply list_drop2_incl; auto. auto with coqlib.
intro. unfold loc_arguments. apply H.
unfold int_param_regs. NoRepet.
@@ -501,32 +561,42 @@ Qed.
(** The offsets of [Outgoing] arguments are below [size_arguments s]. *)
+Remark size_arguments_rec_above:
+ forall tyl iregl fregl ofs0,
+ ofs0 <= size_arguments_rec tyl iregl fregl ofs0.
+Proof.
+ induction tyl; simpl; intros.
+ omega.
+ destruct a.
+ destruct iregl. apply Zle_trans with (ofs0 + 1); auto; omega. auto.
+ destruct fregl. apply Zle_trans with (ofs0 + 2); auto; omega. auto.
+Qed.
+
+Lemma size_arguments_above:
+ forall s, size_arguments s >= 14.
+Proof.
+ intros; unfold size_arguments. apply Zle_ge.
+ apply size_arguments_rec_above.
+Qed.
+
Lemma loc_arguments_bounded:
forall (s: signature) (ofs: Z) (ty: typ),
In (S (Outgoing ofs ty)) (loc_arguments s) ->
ofs + typesize ty <= size_arguments s.
Proof.
intros.
- assert (forall tyl, size_arguments_rec tyl >= 6).
- induction tyl; unfold size_arguments_rec; fold size_arguments_rec; intros.
- omega.
- destruct a; omega.
assert (forall tyl iregl fregl ofs0,
In (S (Outgoing ofs ty)) (loc_arguments_rec tyl iregl fregl ofs0) ->
- ofs + typesize ty <= size_arguments_rec tyl + ofs0 - 6).
- induction tyl; simpl loc_arguments_rec; intros.
- elim H1.
- unfold size_arguments_rec; fold size_arguments_rec.
- destruct a.
- elim H1; intro. destruct iregl; simplify_eq H2; intros.
- subst ty; subst ofs. generalize (H0 tyl). simpl typesize. omega.
- generalize (IHtyl _ _ _ H2). omega.
- elim H1; intro. destruct fregl; simplify_eq H2; intros.
- subst ty; subst ofs. generalize (H0 tyl). simpl typesize. omega.
- generalize (IHtyl _ _ _ H2). omega.
- replace (size_arguments s) with (size_arguments s + 6 - 6).
- unfold size_arguments. eapply H1. unfold loc_arguments in H. eauto.
- omega.
+ ofs + typesize ty <= size_arguments_rec tyl iregl fregl ofs0).
+ induction tyl; simpl; intros.
+ elim H0.
+ destruct a. destruct iregl; elim H0; intro.
+ inv H1. simpl. apply size_arguments_rec_above. auto.
+ discriminate. auto.
+ destruct fregl; elim H0; intro.
+ inv H1. simpl. apply size_arguments_rec_above. auto.
+ discriminate. auto.
+ unfold size_arguments. eapply H0. unfold loc_arguments in H. eauto.
Qed.
(** Temporary registers do not overlap with argument locations. *)
@@ -543,6 +613,18 @@ Proof.
Qed.
Hint Resolve loc_arguments_not_temporaries: locs.
+(** Argument registers are caller-save. *)
+
+Lemma arguments_caller_save:
+ forall sig r,
+ In (R r) (loc_arguments sig) -> In (R r) destroyed_at_call.
+Proof.
+ unfold loc_arguments; intros.
+ elim (loc_arguments_rec_charact _ _ _ _ _ H); simpl.
+ ElimOrEq; intuition.
+ ElimOrEq; intuition.
+Qed.
+
(** Callee-save registers do not overlap with argument locations. *)
Lemma arguments_not_preserved:
@@ -571,7 +653,9 @@ Proof.
List.length (loc_arguments_rec tyl iregl fregl ofs) = List.length tyl).
induction tyl; simpl; intros.
auto.
- destruct a; simpl; decEq; auto.
+ destruct a.
+ destruct iregl; simpl; decEq; auto.
+ destruct fregl; simpl; decEq; auto.
intros. unfold loc_arguments. auto.
Qed.
@@ -586,14 +670,10 @@ Proof.
List.map Loc.type (loc_arguments_rec tyl iregl fregl ofs) = tyl).
induction tyl; simpl; intros.
auto.
- destruct a; simpl; apply (f_equal2 (@cons typ)).
- destruct iregl. reflexivity. simpl. apply H. auto with coqlib.
- apply IHtyl.
- intros. apply H. apply list_drop1_incl. auto. auto.
- destruct fregl. reflexivity. simpl. apply H0. auto with coqlib.
- apply IHtyl.
- intros. apply H. apply list_drop2_incl. auto.
- intros. apply H0. apply list_drop1_incl. auto.
+ destruct a; [destruct iregl|destruct fregl]; simpl;
+ f_equal; eauto with coqlib.
+ apply IHtyl. intros. apply H. apply list_drop2_incl; auto.
+ eauto with coqlib.
intros. unfold loc_arguments. apply H.
intro; simpl. ElimOrEq; reflexivity.
@@ -618,6 +698,30 @@ Proof.
destruct s; try tauto. destruct s0; tauto.
Qed.
+(** A tailcall is possible if and only if the size of arguments is 14. *)
+
+Lemma tailcall_possible_size:
+ forall s, tailcall_possible s <-> size_arguments s = 14.
+Proof.
+ intro; split; intro.
+ assert (forall tyl iregl fregl ofs,
+ (forall l, In l (loc_arguments_rec tyl iregl fregl ofs) ->
+ match l with R _ => True | S _ => False end) ->
+ size_arguments_rec tyl iregl fregl ofs = ofs).
+ induction tyl; simpl; intros.
+ auto.
+ destruct a. destruct iregl. elim (H0 _ (in_eq _ _)).
+ apply IHtyl; intros. apply H0. auto with coqlib.
+ destruct fregl. elim (H0 _ (in_eq _ _)).
+ apply IHtyl; intros. apply H0. auto with coqlib.
+ unfold size_arguments. apply H0. assumption.
+ red; intros.
+ generalize (loc_arguments_acceptable s l H0).
+ destruct l; simpl. auto. destruct s0; intro; auto.
+ generalize (loc_arguments_bounded _ _ _ H0).
+ generalize (typesize_pos t). omega.
+Qed.
+
(** ** Location of function parameters *)
(** A function finds the values of its parameter in the same locations
@@ -645,6 +749,13 @@ Proof.
destruct s; reflexivity.
Qed.
+Lemma loc_parameters_length:
+ forall sg, List.length (loc_parameters sg) = List.length sg.(sig_args).
+Proof.
+ intros. unfold loc_parameters. rewrite list_length_map.
+ apply loc_arguments_length.
+Qed.
+
Lemma loc_parameters_not_temporaries:
forall sig, Loc.disjoint (loc_parameters sig) temporaries.
Proof.
@@ -676,7 +787,7 @@ Proof.
intros; simpl. tauto.
Qed.
-(** ** Location of argument and result of dynamic allocation *)
+(** ** Location of argument and result for dynamic memory allocation *)
Definition loc_alloc_argument := R3.
Definition loc_alloc_result := R3.
diff --git a/backend/LTL.v b/backend/LTL.v
index 0dc970207ebf95b0ba54039e32240d202244fd91..edb8ecc5306780b8e74959bcde1d540a0bfb40df 100644
--- a/backend/LTL.v
+++ b/backend/LTL.v
@@ -3,7 +3,6 @@
LTL (``Location Transfer Language'') is the target language
for register allocation and the source language for linearization. *)
-Require Import Relations.
Require Import Coqlib.
Require Import Maps.
Require Import AST.
@@ -12,54 +11,38 @@ Require Import Values.
Require Import Events.
Require Import Mem.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Op.
Require Import Locations.
-Require Conventions.
+Require Import Conventions.
(** * Abstract syntax *)
-(** LTL is close to RTL, but uses locations instead of pseudo-registers,
- and basic blocks instead of single instructions as nodes of its
- control-flow graph. *)
+(** LTL is close to RTL, but uses locations instead of pseudo-registers. *)
Definition node := positive.
-(** A basic block is a sequence of instructions terminated by
- a [Bgoto], [Bcond] or [Breturn] instruction. (This invariant
- is enforced by the following inductive type definition.)
- The instructions behave like the similarly-named instructions
- of RTL. They take machine registers (type [mreg]) as arguments
- and results. Two new instructions are added: [Bgetstack]
- and [Bsetstack], which are ``move'' instructions between
- a machine register and a stack slot. *)
-
-Inductive block: Set :=
- | Bgetstack: slot -> mreg -> block -> block
- | Bsetstack: mreg -> slot -> block -> block
- | Bop: operation -> list mreg -> mreg -> block -> block
- | Bload: memory_chunk -> addressing -> list mreg -> mreg -> block -> block
- | Bstore: memory_chunk -> addressing -> list mreg -> mreg -> block -> block
- | Bcall: signature -> mreg + ident -> block -> block
- | Balloc: block -> block
- | Bgoto: node -> block
- | Bcond: condition -> list mreg -> node -> node -> block
- | Breturn: block.
-
-Definition code: Set := PTree.t block.
-
-(** Unlike in RTL, parameter passing (passing values of the arguments
- to a function call to the parameters of the called function) is done
- via conventional locations (machine registers and stack slots).
- Consequently, the [Bcall] instruction has no list of argument registers,
- and function descriptions have no list of parameter registers. *)
+Inductive instruction: Set :=
+ | Lnop: node -> instruction
+ | Lop: operation -> list loc -> loc -> node -> instruction
+ | Lload: memory_chunk -> addressing -> list loc -> loc -> node -> instruction
+ | Lstore: memory_chunk -> addressing -> list loc -> loc -> node -> instruction
+ | Lcall: signature -> loc + ident -> list loc -> loc -> node -> instruction
+ | Ltailcall: signature -> loc + ident -> list loc -> instruction
+ | Lalloc: loc -> loc -> node -> instruction
+ | Lcond: condition -> list loc -> node -> node -> instruction
+ | Lreturn: option loc -> instruction.
+
+Definition code: Set := PTree.t instruction.
Record function: Set := mkfunction {
fn_sig: signature;
+ fn_params: list loc;
fn_stacksize: Z;
fn_code: code;
fn_entrypoint: node;
- fn_code_wf:
- forall (pc: node), Plt pc (Psucc fn_entrypoint) \/ fn_code!pc = None
+ fn_nextpc: node;
+ fn_code_wf: forall (pc: node), Plt pc fn_nextpc \/ fn_code!pc = None
}.
Definition fundef := AST.fundef function.
@@ -107,7 +90,7 @@ Definition call_regs (caller: locset) : locset :=
set [callee] of the callee at the return instruction.
- Callee-save machine registers have the same values as in the caller
before the call.
-- Caller-save and temporary machine registers have the same values
+- Caller-save machine registers have the same values
as in the callee at the return point.
- Stack slots have the same values as in the caller before the call.
*)
@@ -125,11 +108,72 @@ Definition return_regs (caller callee: locset) : locset :=
| S s => caller (S s)
end.
+(** [parmov srcs dsts ls] performs the parallel assignment
+ of locations [dsts] to the values of the corresponding locations
+ [srcs]. *)
+
+Fixpoint parmov (srcs dsts: list loc) (ls: locset) {struct srcs} : locset :=
+ match srcs, dsts with
+ | s1 :: sl, d1 :: dl => Locmap.set d1 (ls s1) (parmov sl dl ls)
+ | _, _ => ls
+ end.
+
+Definition set_result_reg (s: signature) (or: option loc) (ls: locset) :=
+ match or with
+ | Some r => Locmap.set (R (loc_result s)) (ls r) ls
+ | None => ls
+ end.
+
+(** The components of an LTL execution state are:
+
+- [State cs f sp pc ls m]: [f] is the function currently executing.
+ [sp] is the stack pointer (as in RTL). [pc] is the current
+ program point (CFG node) within the code of [f].
+ [ls] maps locations to their current values. [m] is the current
+ memory state.
+- [Callstate cs f ls m]:
+ [f] is the function definition that we are calling.
+ [ls] is the values of locations just before the call.
+ [m] is the current memory state.
+- [Returnstate cs sig ls m]:
+ [sig] is the signature of the function that just returned.
+ [ls] is the values of locations just before the return.
+ [m] is the current memory state.
+
+[cs] is a list of stack frames [Stackframe res f sp ls pc],
+where [res] is the location that will receive the result of the call,
+[f] is the calling function, [sp] its stack pointer,
+[ls] the values of locations just before the call,
+and [pc] the program point within [f] of the successor of the
+[Lcall] instruction. *)
+
+Inductive stackframe : Set :=
+ | Stackframe:
+ forall (res: loc) (f: function) (sp: val) (ls: locset) (pc: node),
+ stackframe.
+
+Inductive state : Set :=
+ | State:
+ forall (stack: list stackframe) (f: function) (sp: val)
+ (pc: node) (ls: locset) (m: mem), state
+ | Callstate:
+ forall (stack: list stackframe) (f: fundef) (ls: locset) (m: mem),
+ state
+ | Returnstate:
+ forall (stack: list stackframe) (sig: signature) (ls: locset) (m: mem),
+ state.
+
+Definition parent_locset (stack: list stackframe) : locset :=
+ match stack with
+ | nil => Locmap.init Vundef
+ | Stackframe res f sp ls pc :: stack' => ls
+ end.
+
Variable ge: genv.
-Definition find_function (ros: mreg + ident) (rs: locset) : option fundef :=
- match ros with
- | inl r => Genv.find_funct ge (rs (R r))
+Definition find_function (los: loc + ident) (rs: locset) : option fundef :=
+ match los with
+ | inl l => Genv.find_funct ge (rs l)
| inr symb =>
match Genv.find_symbol ge symb with
| None => None
@@ -137,158 +181,140 @@ Definition find_function (ros: mreg + ident) (rs: locset) : option fundef :=
end
end.
-Definition reglist (rl: list mreg) (rs: locset) : list val :=
- List.map (fun r => rs (R r)) rl.
-
-(** The dynamic semantics of LTL, like that of RTL, is a combination
- of small-step transition semantics and big-step semantics.
- Function calls are treated in big-step style so that they appear
- as a single transition in the caller function. Other instructions
- are treated in purely small-step style, as a single transition.
-
- The introduction of basic blocks increases the number of inductive
- predicates needed to express the semantics:
-- [exec_instr ge sp b ls m b' ls' m'] is the execution of the first
- instruction of block [b]. [b'] is the remainder of the block.
-- [exec_instrs ge sp b ls m b' ls' m'] is similar, but executes
- zero, one or several instructions at the beginning of block [b].
-- [exec_block ge sp b ls m out ls' m'] executes all instructions
- of block [b]. The outcome [out] is either [Cont s], indicating
- that the block terminates by branching to block labeled [s],
- or [Return], indicating that the block terminates by returning
- from the current function.
-- [exec_blocks ge code sp pc ls m out ls' m'] executes a sequence
- of zero, one or several blocks, starting at the block labeled [pc].
- [code] is the control-flow graph for the current function.
- The outcome [out] indicates how the last block in this sequence
- terminates: by branching to another block or by returning from the
- function.
-- [exec_function ge f ls m ls' m'] executes the body of function [f],
- from its entry point to the first [Lreturn] instruction encountered.
-
- In all these predicates, [ls] and [ls'] are the location sets
- (values of locations) at the beginning and end of the transitions,
- respectively.
+(** The main difference between the LTL transition relation
+ and the RTL transition relation is the handling of function calls.
+ In RTL, arguments and results to calls are transmitted via
+ [vargs] and [vres] components of [Callstate] and [Returnstate],
+ respectively. The semantics takes care of transferring these values
+ between the pseudo-registers of the caller and of the callee.
+
+ In lower-level intermediate languages (e.g [Linear], [Mach], [PPC]),
+ arguments and results are transmitted implicitly: the generated
+ code for the caller arranges for arguments to be left in conventional
+ registers and stack locations, as determined by the calling conventions,
+ where the function being called will find them. Similarly,
+ conventional registers will be used to pass the result value back
+ to the caller.
+
+ In LTL, we take an hybrid view of argument and result passing.
+ The LTL code does not contain (yet) instructions for moving
+ arguments and results to the conventional registers. However,
+ the dynamic semantics "goes through the motions" of such code:
+- The [exec_Lcall] transition from [State] to [Callstate]
+ leaves the values of arguments in the conventional locations
+ given by [loc_arguments].
+- The [exec_function_internal] transition from [Callstate] to [State]
+ changes the view of stack slots ([Outgoing] slots slide to
+ [Incoming] slots as per [call_regs]), then recovers the
+ values of parameters from the conventional locations given by
+ [loc_parameters].
+- The [exec_Lreturn] transition from [State] to [Returnstate]
+ moves the result value to the conventional location [loc_result],
+ then restores the values of callee-save locations from
+ the location state of the caller, using [return_regs].
+- The [exec_return] transition from [Returnstate] to [State]
+ reads the result value from the conventional location [loc_result],
+ then stores it in the result location for the [Lcall] instruction.
+
+This complicated protocol will make it much easier to prove
+the correctness of the [Stacking] pass later, which inserts actual
+code that performs all the shuffling of arguments and results
+described above.
*)
-Inductive outcome: Set :=
- | Cont: node -> outcome
- | Return: outcome.
-
-Inductive exec_instr: val ->
- block -> locset -> mem -> trace ->
- block -> locset -> mem -> Prop :=
- | exec_Bgetstack:
- forall sp sl r b rs m,
- exec_instr sp (Bgetstack sl r b) rs m
- E0 b (Locmap.set (R r) (rs (S sl)) rs) m
- | exec_Bsetstack:
- forall sp r sl b rs m,
- exec_instr sp (Bsetstack r sl b) rs m
- E0 b (Locmap.set (S sl) (rs (R r)) rs) m
- | exec_Bop:
- forall sp op args res b rs m v,
- eval_operation ge sp op (reglist args rs) = Some v ->
- exec_instr sp (Bop op args res b) rs m
- E0 b (Locmap.set (R res) v rs) m
- | exec_Bload:
- forall sp chunk addr args dst b rs m a v,
- eval_addressing ge sp addr (reglist args rs) = Some a ->
- loadv chunk m a = Some v ->
- exec_instr sp (Bload chunk addr args dst b) rs m
- E0 b (Locmap.set (R dst) v rs) m
- | exec_Bstore:
- forall sp chunk addr args src b rs m m' a,
- eval_addressing ge sp addr (reglist args rs) = Some a ->
- storev chunk m a (rs (R src)) = Some m' ->
- exec_instr sp (Bstore chunk addr args src b) rs m
- E0 b rs m'
- | exec_Bcall:
- forall sp sig ros b rs m t f rs' m',
- find_function ros rs = Some f ->
- sig = funsig f ->
- exec_function f rs m t rs' m' ->
- exec_instr sp (Bcall sig ros b) rs m
- t b (return_regs rs rs') m'
- | exec_Balloc:
- forall sp b rs m sz m' blk,
- rs (R Conventions.loc_alloc_argument) = Vint sz ->
- Mem.alloc m 0 (Int.signed sz) = (m', blk) ->
- exec_instr sp (Balloc b) rs m E0 b
- (Locmap.set (R Conventions.loc_alloc_result)
- (Vptr blk Int.zero) rs) m'
-
-with exec_instrs: val ->
- block -> locset -> mem -> trace ->
- block -> locset -> mem -> Prop :=
- | exec_refl:
- forall sp b rs m,
- exec_instrs sp b rs m E0 b rs m
- | exec_one:
- forall sp b1 rs1 m1 t b2 rs2 m2,
- exec_instr sp b1 rs1 m1 t b2 rs2 m2 ->
- exec_instrs sp b1 rs1 m1 t b2 rs2 m2
- | exec_trans:
- forall sp b1 rs1 m1 t t1 b2 rs2 m2 t2 b3 rs3 m3,
- exec_instrs sp b1 rs1 m1 t1 b2 rs2 m2 ->
- exec_instrs sp b2 rs2 m2 t2 b3 rs3 m3 ->
- t = t1 ** t2 ->
- exec_instrs sp b1 rs1 m1 t b3 rs3 m3
-
-with exec_block: val ->
- block -> locset -> mem -> trace ->
- outcome -> locset -> mem -> Prop :=
- | exec_Bgoto:
- forall sp b rs m t s rs' m',
- exec_instrs sp b rs m t (Bgoto s) rs' m' ->
- exec_block sp b rs m t (Cont s) rs' m'
- | exec_Bcond_true:
- forall sp b rs m t cond args ifso ifnot rs' m',
- exec_instrs sp b rs m t (Bcond cond args ifso ifnot) rs' m' ->
- eval_condition cond (reglist args rs') = Some true ->
- exec_block sp b rs m t (Cont ifso) rs' m'
- | exec_Bcond_false:
- forall sp b rs m t cond args ifso ifnot rs' m',
- exec_instrs sp b rs m t (Bcond cond args ifso ifnot) rs' m' ->
- eval_condition cond (reglist args rs') = Some false ->
- exec_block sp b rs m t (Cont ifnot) rs' m'
- | exec_Breturn:
- forall sp b rs m t rs' m',
- exec_instrs sp b rs m t Breturn rs' m' ->
- exec_block sp b rs m t Return rs' m'
-
-with exec_blocks: code -> val ->
- node -> locset -> mem -> trace ->
- outcome -> locset -> mem -> Prop :=
- | exec_blocks_refl:
- forall c sp pc rs m,
- exec_blocks c sp pc rs m E0 (Cont pc) rs m
- | exec_blocks_one:
- forall c sp pc b m rs t out rs' m',
- c!pc = Some b ->
- exec_block sp b rs m t out rs' m' ->
- exec_blocks c sp pc rs m t out rs' m'
- | exec_blocks_trans:
- forall c sp pc1 rs1 m1 t t1 pc2 rs2 m2 t2 out rs3 m3,
- exec_blocks c sp pc1 rs1 m1 t1 (Cont pc2) rs2 m2 ->
- exec_blocks c sp pc2 rs2 m2 t2 out rs3 m3 ->
- t = t1 ** t2 ->
- exec_blocks c sp pc1 rs1 m1 t out rs3 m3
-
-with exec_function: fundef -> locset -> mem -> trace ->
- locset -> mem -> Prop :=
- | exec_funct_internal:
- forall f rs m m1 stk t rs2 m2,
- alloc m 0 f.(fn_stacksize) = (m1, stk) ->
- exec_blocks f.(fn_code) (Vptr stk Int.zero)
- f.(fn_entrypoint) (call_regs rs) m1 t Return rs2 m2 ->
- exec_function (Internal f) rs m t rs2 (free m2 stk)
- | exec_funct_external:
- forall ef args res rs1 rs2 m t,
+Inductive step: state -> trace -> state -> Prop :=
+ | exec_Lnop:
+ forall s f sp pc rs m pc',
+ (fn_code f)!pc = Some(Lnop pc') ->
+ step (State s f sp pc rs m)
+ E0 (State s f sp pc' rs m)
+ | exec_Lop:
+ forall s f sp pc rs m op args res pc' v,
+ (fn_code f)!pc = Some(Lop op args res pc') ->
+ eval_operation ge sp op (map rs args) m = Some v ->
+ step (State s f sp pc rs m)
+ E0 (State s f sp pc' (Locmap.set res v rs) m)
+ | exec_Lload:
+ forall s f sp pc rs m chunk addr args dst pc' a v,
+ (fn_code f)!pc = Some(Lload chunk addr args dst pc') ->
+ eval_addressing ge sp addr (map rs args) = Some a ->
+ Mem.loadv chunk m a = Some v ->
+ step (State s f sp pc rs m)
+ E0 (State s f sp pc' (Locmap.set dst v rs) m)
+ | exec_Lstore:
+ forall s f sp pc rs m chunk addr args src pc' a m',
+ (fn_code f)!pc = Some(Lstore chunk addr args src pc') ->
+ eval_addressing ge sp addr (map rs args) = Some a ->
+ Mem.storev chunk m a (rs src) = Some m' ->
+ step (State s f sp pc rs m)
+ E0 (State s f sp pc' rs m')
+ | exec_Lcall:
+ forall s f sp pc rs m sig ros args res pc' f',
+ (fn_code f)!pc = Some(Lcall sig ros args res pc') ->
+ find_function ros rs = Some f' ->
+ funsig f' = sig ->
+ let rs1 := parmov args (loc_arguments sig) rs in
+ step (State s f sp pc rs m)
+ E0 (Callstate (Stackframe res f sp rs1 pc' :: s) f' rs1 m)
+ | exec_Ltailcall:
+ forall s f stk pc rs m sig ros args f',
+ (fn_code f)!pc = Some(Ltailcall sig ros args) ->
+ find_function ros rs = Some f' ->
+ funsig f' = sig ->
+ let rs1 := parmov args (loc_arguments sig) rs in
+ let rs2 := return_regs (parent_locset s) rs1 in
+ step (State s f (Vptr stk Int.zero) pc rs m)
+ E0 (Callstate s f' rs2 (Mem.free m stk))
+ | exec_Lalloc:
+ forall s f sp pc rs m pc' arg res sz m' b,
+ (fn_code f)!pc = Some(Lalloc arg res pc') ->
+ rs arg = Vint sz ->
+ Mem.alloc m 0 (Int.signed sz) = (m', b) ->
+ let rs1 := Locmap.set (R loc_alloc_argument) (rs arg) rs in
+ let rs2 := Locmap.set (R loc_alloc_result) (Vptr b Int.zero) rs1 in
+ let rs3 := Locmap.set res (rs2 (R loc_alloc_result)) rs2 in
+ step (State s f sp pc rs m)
+ E0 (State s f sp pc' rs3 m')
+ | exec_Lcond_true:
+ forall s f sp pc rs m cond args ifso ifnot,
+ (fn_code f)!pc = Some(Lcond cond args ifso ifnot) ->
+ eval_condition cond (map rs args) m = Some true ->
+ step (State s f sp pc rs m)
+ E0 (State s f sp ifso rs m)
+ | exec_Lcond_false:
+ forall s f sp pc rs m cond args ifso ifnot,
+ (fn_code f)!pc = Some(Lcond cond args ifso ifnot) ->
+ eval_condition cond (map rs args) m = Some false ->
+ step (State s f sp pc rs m)
+ E0 (State s f sp ifnot rs m)
+ | exec_Lreturn:
+ forall s f stk pc rs m or,
+ (fn_code f)!pc = Some(Lreturn or) ->
+ let rs1 := set_result_reg f.(fn_sig) or rs in
+ let rs2 := return_regs (parent_locset s) rs1 in
+ step (State s f (Vptr stk Int.zero) pc rs m)
+ E0 (Returnstate s f.(fn_sig) rs2 (Mem.free m stk))
+ | exec_function_internal:
+ forall s f rs m m' stk,
+ Mem.alloc m 0 f.(fn_stacksize) = (m', stk) ->
+ let rs1 := call_regs rs in
+ let rs2 := parmov (loc_parameters f.(fn_sig)) f.(fn_params) rs1 in
+ step (Callstate s (Internal f) rs m)
+ E0 (State s f (Vptr stk Int.zero) f.(fn_entrypoint) rs2 m')
+ | exec_function_external:
+ forall s ef t res rs m,
+ let args := map rs (Conventions.loc_arguments ef.(ef_sig)) in
event_match ef args t res ->
- args = List.map rs1 (Conventions.loc_arguments ef.(ef_sig)) ->
- rs2 = Locmap.set (R (Conventions.loc_result ef.(ef_sig))) res rs1 ->
- exec_function (External ef) rs1 m t rs2 m.
+ let rs1 :=
+ Locmap.set (R (Conventions.loc_result ef.(ef_sig))) res rs in
+ step (Callstate s (External ef) rs m)
+ t (Returnstate s ef.(ef_sig) rs1 m)
+ | exec_return:
+ forall res f sp rs0 pc s sig rs m,
+ let rs1 := Locmap.set res (rs (R (loc_result sig))) rs in
+ step (Returnstate (Stackframe res f sp rs0 pc :: s)
+ sig rs m)
+ E0 (State s f sp pc rs1 m).
End RELSEM.
@@ -297,87 +323,41 @@ End RELSEM.
main function, to be found in the machine register dictated
by the calling conventions. *)
-Definition exec_program (p: program) (t: trace) (r: val) : Prop :=
- let ge := Genv.globalenv p in
- let m0 := Genv.init_mem p in
- exists b, exists f, exists rs, exists m,
- Genv.find_symbol ge p.(prog_main) = Some b /\
- Genv.find_funct_ptr ge b = Some f /\
- funsig f = mksignature nil (Some Tint) /\
- exec_function ge f (Locmap.init Vundef) m0 t rs m /\
- rs (R (Conventions.loc_result (funsig f))) = r.
-
-(** We remark that the [exec_blocks] relation is stable if
- the control-flow graph is extended by adding new basic blocks
- at previously unused graph nodes. *)
+Inductive initial_state (p: program): state -> Prop :=
+ | initial_state_intro: forall b f,
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ Genv.find_symbol ge p.(prog_main) = Some b ->
+ Genv.find_funct_ptr ge b = Some f ->
+ funsig f = mksignature nil (Some Tint) ->
+ initial_state p (Callstate nil f (Locmap.init Vundef) m0).
-Section EXEC_BLOCKS_EXTENDS.
+Inductive final_state: state -> int -> Prop :=
+ | final_state_intro: forall sig rs m r,
+ rs (R (loc_result sig)) = Vint r ->
+ final_state (Returnstate nil sig rs m) r.
-Variable ge: genv.
-Variable c1 c2: code.
-Hypothesis EXT: forall pc, c2!pc = c1!pc \/ c1!pc = None.
-
-Lemma exec_blocks_extends:
- forall sp pc1 rs1 m1 t out rs2 m2,
- exec_blocks ge c1 sp pc1 rs1 m1 t out rs2 m2 ->
- exec_blocks ge c2 sp pc1 rs1 m1 t out rs2 m2.
-Proof.
- induction 1.
- apply exec_blocks_refl.
- apply exec_blocks_one with b.
- elim (EXT pc); intro; congruence. assumption.
- eapply exec_blocks_trans; eauto.
-Qed.
-
-End EXEC_BLOCKS_EXTENDS.
+Definition exec_program (p: program) (beh: program_behavior) : Prop :=
+ program_behaves step (initial_state p) final_state (Genv.globalenv p) beh.
(** * Operations over LTL *)
-(** Computation of the possible successors of a basic block.
- This is used for dataflow analyses. *)
-
-Fixpoint successors_aux (b: block) : list node :=
- match b with
- | Bgetstack s r b => successors_aux b
- | Bsetstack r s b => successors_aux b
- | Bop op args res b => successors_aux b
- | Bload chunk addr args dst b => successors_aux b
- | Bstore chunk addr args src b => successors_aux b
- | Bcall sig ros b => successors_aux b
- | Balloc b => successors_aux b
- | Bgoto n => n :: nil
- | Bcond cond args ifso ifnot => ifso :: ifnot :: nil
- | Breturn => nil
- end.
+(** Computation of the possible successors of an instruction.
+ This is used in particular for dataflow analyses. *)
Definition successors (f: function) (pc: node) : list node :=
match f.(fn_code)!pc with
| None => nil
- | Some b => successors_aux b
+ | Some i =>
+ match i with
+ | Lnop s => s :: nil
+ | Lop op args res s => s :: nil
+ | Lload chunk addr args dst s => s :: nil
+ | Lstore chunk addr args src s => s :: nil
+ | Lcall sig ros args res s => s :: nil
+ | Ltailcall sig ros args => nil
+ | Lalloc arg res s => s :: nil
+ | Lcond cond args ifso ifnot => ifso :: ifnot :: nil
+ | Lreturn optarg => nil
+ end
end.
-
-Lemma successors_aux_invariant:
- forall ge sp b rs m t b' rs' m',
- exec_instrs ge sp b rs m t b' rs' m' ->
- successors_aux b = successors_aux b'.
-Proof.
- induction 1; simpl; intros.
- reflexivity.
- inversion H; reflexivity.
- transitivity (successors_aux b2); auto.
-Qed.
-
-Lemma successors_correct:
- forall ge f sp pc rs m t pc' rs' m' b,
- f.(fn_code)!pc = Some b ->
- exec_block ge sp b rs m t (Cont pc') rs' m' ->
- In pc' (successors f pc).
-Proof.
- intros. unfold successors. rewrite H. inversion H0.
- rewrite (successors_aux_invariant _ _ _ _ _ _ _ _ _ H7); simpl.
- tauto.
- rewrite (successors_aux_invariant _ _ _ _ _ _ _ _ _ H2); simpl.
- tauto.
- rewrite (successors_aux_invariant _ _ _ _ _ _ _ _ _ H2); simpl.
- tauto.
-Qed.
diff --git a/backend/LTLin.v b/backend/LTLin.v
new file mode 100644
index 0000000000000000000000000000000000000000..368c13cd94fecca48862bae1af94876b64114a6f
--- /dev/null
+++ b/backend/LTLin.v
@@ -0,0 +1,255 @@
+(** The LTLin intermediate language: abstract syntax and semantcs *)
+
+(** The LTLin language is a variant of LTL where control-flow is not
+ expressed as a graph of basic blocks, but as a linear list of
+ instructions with explicit labels and ``goto'' instructions. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Integers.
+Require Import Values.
+Require Import Mem.
+Require Import Events.
+Require Import Globalenvs.
+Require Import Smallstep.
+Require Import Op.
+Require Import Locations.
+Require Import LTL.
+Require Import Conventions.
+
+(** * Abstract syntax *)
+
+Definition label := positive.
+
+(** LTLin instructions are similar to those of LTL.
+ Except the last three, these instructions continue in sequence
+ with the next instruction in the linear list of instructions.
+ Unconditional branches [Lgoto] and conditional branches [Lcond]
+ transfer control to the given code label. Labels are explicitly
+ inserted in the instruction list as pseudo-instructions [Llabel]. *)
+
+Inductive instruction: Set :=
+ | Lop: operation -> list loc -> loc -> instruction
+ | Lload: memory_chunk -> addressing -> list loc -> loc -> instruction
+ | Lstore: memory_chunk -> addressing -> list loc -> loc -> instruction
+ | Lcall: signature -> loc + ident -> list loc -> loc -> instruction
+ | Ltailcall: signature -> loc + ident -> list loc -> instruction
+ | Lalloc: loc -> loc -> instruction
+ | Llabel: label -> instruction
+ | Lgoto: label -> instruction
+ | Lcond: condition -> list loc -> label -> instruction
+ | Lreturn: option loc -> instruction.
+
+Definition code: Set := list instruction.
+
+Record function: Set := mkfunction {
+ fn_sig: signature;
+ fn_params: list loc;
+ fn_stacksize: Z;
+ fn_code: code
+}.
+
+Definition fundef := AST.fundef function.
+
+Definition program := AST.program fundef unit.
+
+Definition funsig (fd: fundef) :=
+ match fd with
+ | Internal f => f.(fn_sig)
+ | External ef => ef.(ef_sig)
+ end.
+
+Definition genv := Genv.t fundef.
+Definition locset := Locmap.t.
+
+(** * Operational semantics *)
+
+(** Looking up labels in the instruction list. *)
+
+Definition is_label (lbl: label) (instr: instruction) : bool :=
+ match instr with
+ | Llabel lbl' => if peq lbl lbl' then true else false
+ | _ => false
+ end.
+
+Lemma is_label_correct:
+ forall lbl instr,
+ if is_label lbl instr then instr = Llabel lbl else instr <> Llabel lbl.
+Proof.
+ intros. destruct instr; simpl; try discriminate.
+ case (peq lbl l); intro; congruence.
+Qed.
+
+(** [find_label lbl c] returns a list of instruction, suffix of the
+ code [c], that immediately follows the [Llabel lbl] pseudo-instruction.
+ If the label [lbl] is multiply-defined, the first occurrence is
+ retained. If the label [lbl] is not defined, [None] is returned. *)
+
+Fixpoint find_label (lbl: label) (c: code) {struct c} : option code :=
+ match c with
+ | nil => None
+ | i1 :: il => if is_label lbl i1 then Some il else find_label lbl il
+ end.
+
+(** The states of the dynamic semantics are similar to those used
+ in the LTL semantics (see module [LTL]). The only difference
+ is that program points [pc] (nodes of the CFG in LTL) become
+ code sequences [c] (suffixes of the code of the current function).
+*)
+
+Inductive stackframe : Set :=
+ | Stackframe:
+ forall (res: loc) (f: function) (sp: val) (ls: locset) (c: code),
+ stackframe.
+
+Inductive state : Set :=
+ | State:
+ forall (stack: list stackframe) (f: function) (sp: val)
+ (c: code) (ls: locset) (m: mem), state
+ | Callstate:
+ forall (stack: list stackframe) (f: fundef) (ls: locset) (m: mem),
+ state
+ | Returnstate:
+ forall (stack: list stackframe) (sig: signature) (ls: locset) (m: mem),
+ state.
+
+Definition parent_locset (stack: list stackframe) : locset :=
+ match stack with
+ | nil => Locmap.init Vundef
+ | Stackframe res f sp ls pc :: stack' => ls
+ end.
+
+Section RELSEM.
+
+Variable ge: genv.
+
+Definition find_function (ros: loc + ident) (rs: locset) : option fundef :=
+ match ros with
+ | inl r => Genv.find_funct ge (rs r)
+ | inr symb =>
+ match Genv.find_symbol ge symb with
+ | None => None
+ | Some b => Genv.find_funct_ptr ge b
+ end
+ end.
+
+Inductive step: state -> trace -> state -> Prop :=
+ | exec_Lop:
+ forall s f sp op args res b rs m v,
+ eval_operation ge sp op (map rs args) m = Some v ->
+ step (State s f sp (Lop op args res :: b) rs m)
+ E0 (State s f sp b (Locmap.set res v rs) m)
+ | exec_Lload:
+ forall s f sp chunk addr args dst b rs m a v,
+ eval_addressing ge sp addr (map rs args) = Some a ->
+ loadv chunk m a = Some v ->
+ step (State s f sp (Lload chunk addr args dst :: b) rs m)
+ E0 (State s f sp b (Locmap.set dst v rs) m)
+ | exec_Lstore:
+ forall s f sp chunk addr args src b rs m m' a,
+ eval_addressing ge sp addr (map rs args) = Some a ->
+ storev chunk m a (rs src) = Some m' ->
+ step (State s f sp (Lstore chunk addr args src :: b) rs m)
+ E0 (State s f sp b rs m')
+ | exec_Lcall:
+ forall s f sp sig ros args res b rs m f',
+ find_function ros rs = Some f' ->
+ sig = funsig f' ->
+ let rs1 := parmov args (loc_arguments sig) rs in
+ step (State s f sp (Lcall sig ros args res :: b) rs m)
+ E0 (Callstate (Stackframe res f sp rs1 b :: s) f' rs1 m)
+ | exec_Ltailcall:
+ forall s f stk sig ros args b rs m f',
+ find_function ros rs = Some f' ->
+ sig = funsig f' ->
+ let rs1 := parmov args (loc_arguments sig) rs in
+ let rs2 := return_regs (parent_locset s) rs1 in
+ step (State s f (Vptr stk Int.zero) (Ltailcall sig ros args :: b) rs m)
+ E0 (Callstate s f' rs2 (Mem.free m stk))
+ | exec_Lalloc:
+ forall s f sp arg res b rs m sz m' blk,
+ rs arg = Vint sz ->
+ Mem.alloc m 0 (Int.signed sz) = (m', blk) ->
+ let rs1 := Locmap.set (R loc_alloc_argument) (rs arg) rs in
+ let rs2 := Locmap.set (R loc_alloc_result) (Vptr blk Int.zero) rs1 in
+ let rs3 := Locmap.set res (rs2 (R loc_alloc_result)) rs2 in
+ step (State s f sp (Lalloc arg res :: b) rs m)
+ E0 (State s f sp b rs3 m')
+ | exec_Llabel:
+ forall s f sp lbl b rs m,
+ step (State s f sp (Llabel lbl :: b) rs m)
+ E0 (State s f sp b rs m)
+ | exec_Lgoto:
+ forall s f sp lbl b rs m b',
+ find_label lbl f.(fn_code) = Some b' ->
+ step (State s f sp (Lgoto lbl :: b) rs m)
+ E0 (State s f sp b' rs m)
+ | exec_Lcond_true:
+ forall s f sp cond args lbl b rs m b',
+ eval_condition cond (map rs args) m = Some true ->
+ find_label lbl f.(fn_code) = Some b' ->
+ step (State s f sp (Lcond cond args lbl :: b) rs m)
+ E0 (State s f sp b' rs m)
+ | exec_Lcond_false:
+ forall s f sp cond args lbl b rs m,
+ eval_condition cond (map rs args) m = Some false ->
+ step (State s f sp (Lcond cond args lbl :: b) rs m)
+ E0 (State s f sp b rs m)
+ | exec_Lreturn:
+ forall s f stk rs m or b,
+ let rs1 := set_result_reg f.(fn_sig) or rs in
+ let rs2 := return_regs (parent_locset s) rs1 in
+ step (State s f (Vptr stk Int.zero) (Lreturn or :: b) rs m)
+ E0 (Returnstate s f.(fn_sig) rs2 (Mem.free m stk))
+ | exec_function_internal:
+ forall s f rs m m' stk,
+ Mem.alloc m 0 f.(fn_stacksize) = (m', stk) ->
+ let rs1 := call_regs rs in
+ let rs2 := parmov (loc_parameters f.(fn_sig)) f.(fn_params) rs1 in
+ step (Callstate s (Internal f) rs m)
+ E0 (State s f (Vptr stk Int.zero) f.(fn_code) rs2 m')
+ | exec_function_external:
+ forall s ef t res rs m,
+ let args := map rs (Conventions.loc_arguments ef.(ef_sig)) in
+ event_match ef args t res ->
+ let rs1 :=
+ Locmap.set (R (Conventions.loc_result ef.(ef_sig))) res rs in
+ step (Callstate s (External ef) rs m)
+ t (Returnstate s ef.(ef_sig) rs1 m)
+ | exec_return:
+ forall res f sp rs0 b s sig rs m,
+ let rs1 := Locmap.set res (rs (R (loc_result sig))) rs in
+ step (Returnstate (Stackframe res f sp rs0 b :: s) sig rs m)
+ E0 (State s f sp b rs1 m).
+
+End RELSEM.
+
+Inductive initial_state (p: program): state -> Prop :=
+ | initial_state_intro: forall b f,
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ Genv.find_symbol ge p.(prog_main) = Some b ->
+ Genv.find_funct_ptr ge b = Some f ->
+ funsig f = mksignature nil (Some Tint) ->
+ initial_state p (Callstate nil f (Locmap.init Vundef) m0).
+
+Inductive final_state: state -> int -> Prop :=
+ | final_state_intro: forall sig rs m r,
+ rs (R (loc_result sig)) = Vint r ->
+ final_state (Returnstate nil sig rs m) r.
+
+Definition exec_program (p: program) (beh: program_behavior) : Prop :=
+ program_behaves step (initial_state p) final_state (Genv.globalenv p) beh.
+
+(** * Properties of the operational semantics *)
+
+Lemma find_label_is_tail:
+ forall lbl c c', find_label lbl c = Some c' -> is_tail c' c.
+Proof.
+ induction c; simpl; intros.
+ discriminate.
+ destruct (is_label lbl a). inv H. constructor. constructor.
+ constructor. auto.
+Qed.
+
diff --git a/backend/LTLintyping.v b/backend/LTLintyping.v
new file mode 100644
index 0000000000000000000000000000000000000000..06c50f8be66d268add5b373745a229a8043374a4
--- /dev/null
+++ b/backend/LTLintyping.v
@@ -0,0 +1,104 @@
+(** Typing rules for LTLin. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Op.
+Require Import RTL.
+Require Import Locations.
+Require Import LTLin.
+Require Import Conventions.
+
+(** The following predicates define a type system for LTLin similar to that
+ of LTL. *)
+
+Section WT_INSTR.
+
+Variable funsig: signature.
+
+Inductive wt_instr : instruction -> Prop :=
+ | wt_Lopmove:
+ forall r1 r,
+ Loc.type r1 = Loc.type r -> loc_acceptable r1 -> loc_acceptable r ->
+ wt_instr (Lop Omove (r1 :: nil) r)
+ | wt_Lop:
+ forall op args res,
+ op <> Omove ->
+ (List.map Loc.type args, Loc.type res) = type_of_operation op ->
+ locs_acceptable args -> loc_acceptable res ->
+ wt_instr (Lop op args res)
+ | wt_Lload:
+ forall chunk addr args dst,
+ List.map Loc.type args = type_of_addressing addr ->
+ Loc.type dst = type_of_chunk chunk ->
+ locs_acceptable args -> loc_acceptable dst ->
+ wt_instr (Lload chunk addr args dst)
+ | wt_Lstore:
+ forall chunk addr args src,
+ List.map Loc.type args = type_of_addressing addr ->
+ Loc.type src = type_of_chunk chunk ->
+ locs_acceptable args -> loc_acceptable src ->
+ wt_instr (Lstore chunk addr args src)
+ | wt_Lcall:
+ forall sig ros args res,
+ match ros with inl r => Loc.type r = Tint | inr s => True end ->
+ List.map Loc.type args = sig.(sig_args) ->
+ Loc.type res = match sig.(sig_res) with None => Tint | Some ty => ty end ->
+ match ros with inl r => loc_acceptable r | inr s => True end ->
+ locs_acceptable args -> loc_acceptable res ->
+ wt_instr (Lcall sig ros args res)
+ | wt_Ltailcall:
+ forall sig ros args,
+ match ros with inl r => Loc.type r = Tint | inr s => True end ->
+ List.map Loc.type args = sig.(sig_args) ->
+ match ros with inl r => loc_acceptable r | inr s => True end ->
+ locs_acceptable args ->
+ sig.(sig_res) = funsig.(sig_res) ->
+ Conventions.tailcall_possible sig ->
+ wt_instr (Ltailcall sig ros args)
+ | wt_Lalloc:
+ forall arg res,
+ Loc.type arg = Tint -> Loc.type res = Tint ->
+ loc_acceptable arg -> loc_acceptable res ->
+ wt_instr (Lalloc arg res)
+ | wt_Llabel: forall lbl,
+ wt_instr (Llabel lbl)
+ | wt_Lgoto: forall lbl,
+ wt_instr (Lgoto lbl)
+ | wt_Lcond:
+ forall cond args lbl,
+ List.map Loc.type args = type_of_condition cond ->
+ locs_acceptable args ->
+ wt_instr (Lcond cond args lbl)
+ | wt_Lreturn:
+ forall optres,
+ option_map Loc.type optres = funsig.(sig_res) ->
+ match optres with None => True | Some r => loc_acceptable r end ->
+ wt_instr (Lreturn optres).
+
+Definition wt_code (c: code) : Prop :=
+ forall i, In i c -> wt_instr i.
+
+End WT_INSTR.
+
+Record wt_function (f: function): Prop :=
+ mk_wt_function {
+ wt_params:
+ List.map Loc.type f.(fn_params) = f.(fn_sig).(sig_args);
+ wt_acceptable:
+ locs_acceptable f.(fn_params);
+ wt_norepet:
+ Loc.norepet f.(fn_params);
+ wt_instrs:
+ wt_code f.(fn_sig) f.(fn_code)
+}.
+
+Inductive wt_fundef: fundef -> Prop :=
+ | wt_fundef_external: forall ef,
+ wt_fundef (External ef)
+ | wt_function_internal: forall f,
+ wt_function f ->
+ wt_fundef (Internal f).
+
+Definition wt_program (p: program): Prop :=
+ forall i f, In (i, f) (prog_funct p) -> wt_fundef f.
diff --git a/backend/LTLtyping.v b/backend/LTLtyping.v
index 187c5cb8a58a3b3961412a33d9eed920b6e14d3b..646edc827fb1a16e6ce2fee980fac0ce3950c39d 100644
--- a/backend/LTLtyping.v
+++ b/backend/LTLtyping.v
@@ -13,84 +13,99 @@ Require Import Conventions.
of [RTL] (see file [RTLtyping]): it statically guarantees that operations
and addressing modes are applied to the right number of arguments
and that the arguments are of the correct types. Moreover, it also
- enforces some correctness conditions on the offsets of stack slots
- accessed through [Bgetstack] and [Bsetstack] LTL instructions. *)
+ guarantees that the locations of arguments and results are "acceptable",
+ i.e. either non-temporary registers or [Local] stack locations. *)
-Section WT_BLOCK.
+Section WT_INSTR.
Variable funct: function.
-Definition slot_bounded (s: slot) :=
- match s with
- | Local ofs ty => 0 <= ofs
- | Outgoing ofs ty => 6 <= ofs
- | Incoming ofs ty => 6 <= ofs /\ ofs + typesize ty <= size_arguments funct.(fn_sig)
- end.
+Definition valid_successor (s: node) : Prop :=
+ exists i, funct.(fn_code)!s = Some i.
-Inductive wt_block : block -> Prop :=
- | wt_Bgetstack:
- forall s r b,
- slot_type s = mreg_type r ->
- slot_bounded s ->
- wt_block b ->
- wt_block (Bgetstack s r b)
- | wt_Bsetstack:
- forall r s b,
- match s with Incoming _ _ => False | _ => True end ->
- slot_type s = mreg_type r ->
- slot_bounded s ->
- wt_block b ->
- wt_block (Bsetstack r s b)
- | wt_Bopmove:
- forall r1 r b,
- mreg_type r1 = mreg_type r ->
- wt_block b ->
- wt_block (Bop Omove (r1 :: nil) r b)
- | wt_Bopundef:
- forall r b,
- wt_block b ->
- wt_block (Bop Oundef nil r b)
- | wt_Bop:
- forall op args res b,
- op <> Omove -> op <> Oundef ->
- (List.map mreg_type args, mreg_type res) = type_of_operation op ->
- wt_block b ->
- wt_block (Bop op args res b)
- | wt_Bload:
- forall chunk addr args dst b,
- List.map mreg_type args = type_of_addressing addr ->
- mreg_type dst = type_of_chunk chunk ->
- wt_block b ->
- wt_block (Bload chunk addr args dst b)
- | wt_Bstore:
- forall chunk addr args src b,
- List.map mreg_type args = type_of_addressing addr ->
- mreg_type src = type_of_chunk chunk ->
- wt_block b ->
- wt_block (Bstore chunk addr args src b)
- | wt_Bcall:
- forall sig ros b,
- match ros with inl r => mreg_type r = Tint | _ => True end ->
- wt_block b ->
- wt_block (Bcall sig ros b)
- | wt_Balloc:
- forall b,
- wt_block b ->
- wt_block (Balloc b)
- | wt_Bgoto:
- forall lbl,
- wt_block (Bgoto lbl)
- | wt_Bcond:
- forall cond args ifso ifnot,
- List.map mreg_type args = type_of_condition cond ->
- wt_block (Bcond cond args ifso ifnot)
- | wt_Breturn:
- wt_block (Breturn).
+Inductive wt_instr : instruction -> Prop :=
+ | wt_Lnop:
+ forall s,
+ valid_successor s ->
+ wt_instr (Lnop s)
+ | wt_Lopmove:
+ forall r1 r s,
+ Loc.type r1 = Loc.type r -> loc_acceptable r1 -> loc_acceptable r ->
+ valid_successor s ->
+ wt_instr (Lop Omove (r1 :: nil) r s)
+ | wt_Lop:
+ forall op args res s,
+ op <> Omove ->
+ (List.map Loc.type args, Loc.type res) = type_of_operation op ->
+ locs_acceptable args -> loc_acceptable res ->
+ valid_successor s ->
+ wt_instr (Lop op args res s)
+ | wt_Lload:
+ forall chunk addr args dst s,
+ List.map Loc.type args = type_of_addressing addr ->
+ Loc.type dst = type_of_chunk chunk ->
+ locs_acceptable args -> loc_acceptable dst ->
+ valid_successor s ->
+ wt_instr (Lload chunk addr args dst s)
+ | wt_Lstore:
+ forall chunk addr args src s,
+ List.map Loc.type args = type_of_addressing addr ->
+ Loc.type src = type_of_chunk chunk ->
+ locs_acceptable args -> loc_acceptable src ->
+ valid_successor s ->
+ wt_instr (Lstore chunk addr args src s)
+ | wt_Lcall:
+ forall sig ros args res s,
+ match ros with inl r => Loc.type r = Tint | inr s => True end ->
+ List.map Loc.type args = sig.(sig_args) ->
+ Loc.type res = proj_sig_res sig ->
+ match ros with inl r => loc_acceptable r | inr s => True end ->
+ locs_acceptable args -> loc_acceptable res ->
+ valid_successor s ->
+ wt_instr (Lcall sig ros args res s)
+ | wt_Ltailcall:
+ forall sig ros args,
+ match ros with inl r => Loc.type r = Tint | inr s => True end ->
+ List.map Loc.type args = sig.(sig_args) ->
+ match ros with inl r => loc_acceptable r | inr s => True end ->
+ locs_acceptable args ->
+ sig.(sig_res) = funct.(fn_sig).(sig_res) ->
+ Conventions.tailcall_possible sig ->
+ wt_instr (Ltailcall sig ros args)
+ | wt_Lalloc:
+ forall arg res s,
+ Loc.type arg = Tint -> Loc.type res = Tint ->
+ loc_acceptable arg -> loc_acceptable res ->
+ valid_successor s ->
+ wt_instr (Lalloc arg res s)
+ | wt_Lcond:
+ forall cond args s1 s2,
+ List.map Loc.type args = type_of_condition cond ->
+ locs_acceptable args ->
+ valid_successor s1 -> valid_successor s2 ->
+ wt_instr (Lcond cond args s1 s2)
+ | wt_Lreturn:
+ forall optres,
+ option_map Loc.type optres = funct.(fn_sig).(sig_res) ->
+ match optres with None => True | Some r => loc_acceptable r end ->
+ wt_instr (Lreturn optres).
-End WT_BLOCK.
+End WT_INSTR.
-Definition wt_function (f: function) : Prop :=
- forall pc b, f.(fn_code)!pc = Some b -> wt_block f b.
+Record wt_function (f: function): Prop :=
+ mk_wt_function {
+ wt_params:
+ List.map Loc.type f.(fn_params) = f.(fn_sig).(sig_args);
+ wt_acceptable:
+ locs_acceptable f.(fn_params);
+ wt_norepet:
+ Loc.norepet f.(fn_params);
+ wt_instrs:
+ forall pc instr,
+ f.(fn_code)!pc = Some instr -> wt_instr f instr;
+ wt_entrypoint:
+ valid_successor f f.(fn_entrypoint)
+}.
Inductive wt_fundef: fundef -> Prop :=
| wt_fundef_external: forall ef,
@@ -99,6 +114,5 @@ Inductive wt_fundef: fundef -> Prop :=
wt_function f ->
wt_fundef (Internal f).
-Definition wt_program (p: program) : Prop :=
+Definition wt_program (p: program): Prop :=
forall i f, In (i, f) (prog_funct p) -> wt_fundef f.
-
diff --git a/backend/Linear.v b/backend/Linear.v
index 0f1a31f2e56cafca87fed7ebdfa419743a51c022..658037101c6cca0464875ce83f95de5e93fa1167 100644
--- a/backend/Linear.v
+++ b/backend/Linear.v
@@ -1,10 +1,10 @@
(** The Linear intermediate language: abstract syntax and semantcs *)
-(** The Linear language is a variant of LTL where control-flow is not
- expressed as a graph of basic blocks, but as a linear list of
- instructions with explicit labels and ``goto'' instructions. *)
+(** The Linear language is a variant of LTLin where arithmetic
+ instructions operate on machine registers (type [mreg]) instead
+ of arbitrary locations. Special instructions [Lgetstack] and
+ [Lsetstack] are provided to access stack slots. *)
-Require Import Relations.
Require Import Coqlib.
Require Import Maps.
Require Import AST.
@@ -13,24 +13,16 @@ Require Import Values.
Require Import Mem.
Require Import Events.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Op.
Require Import Locations.
Require Import LTL.
-Require Conventions.
+Require Import Conventions.
(** * Abstract syntax *)
Definition label := positive.
-(** Linear instructions are similar to their LTL counterpart:
- arguments and results are machine registers, except for the
- [Lgetstack] and [Lsetstack] instructions which are register-stack moves.
- Except the last three, these instructions continue in sequence
- with the next instruction in the linear list of instructions.
- Unconditional branches [Lgoto] and conditional branches [Lcond]
- transfer control to the given code label. Labels are explicitly
- inserted in the instruction list as pseudo-instructions [Llabel]. *)
-
Inductive instruction: Set :=
| Lgetstack: slot -> mreg -> instruction
| Lsetstack: mreg -> slot -> instruction
@@ -38,6 +30,7 @@ Inductive instruction: Set :=
| Lload: memory_chunk -> addressing -> list mreg -> mreg -> instruction
| Lstore: memory_chunk -> addressing -> list mreg -> mreg -> instruction
| Lcall: signature -> mreg + ident -> instruction
+ | Ltailcall: signature -> mreg + ident -> instruction
| Lalloc: instruction
| Llabel: label -> instruction
| Lgoto: label -> instruction
@@ -108,121 +101,161 @@ Definition find_function (ros: mreg + ident) (rs: locset) : option fundef :=
end
end.
-(** [exec_instr ge f sp c ls m c' ls' m'] represents the execution
- of the first instruction in the code sequence [c]. [ls] and [m]
- are the initial location set and memory state, respectively.
- [c'] is the current code sequence after execution of the instruction:
- it is the tail of [c] if the instruction falls through.
- [ls'] and [m'] are the final location state and memory state. *)
+Definition reglist (rs: locset) (rl: list mreg) : list val :=
+ List.map (fun r => rs (R r)) rl.
+
+(** The components of a Linear execution state are:
+
+- [State cs f sp c rs m]: [f] is the function currently executing.
+ [sp] is the stack pointer. [c] is the sequence of instructions
+ that remain to be executed.
+ [rs] maps locations to their current values. [m] is the current
+ memory state.
+
+- [Callstate cs f rs m]:
+ [f] is the function definition that we are calling.
+ [rs] is the values of locations just before the call.
+ [m] is the current memory state.
+
+- [Returnstate cs rs m]:
+ [rs] is the values of locations just before the return.
+ [m] is the current memory state.
+
+[cs] is a list of stack frames [Stackframe res f rs pc].
+[f] is the calling function, [sp] its stack pointer.
+[rs] the values of locations just before the call.
+[c] is the sequence of instructions following the call in the code of [f].
+*)
+
+Inductive stackframe: Set :=
+ | Stackframe:
+ forall (f: function) (sp: val) (rs: locset) (c: code),
+ stackframe.
+
+Inductive state: Set :=
+ | State:
+ forall (stack: list stackframe) (f: function) (sp: val)
+ (c: code) (rs: locset) (m: mem),
+ state
+ | Callstate:
+ forall (stack: list stackframe) (f: fundef) (rs: locset) (m: mem),
+ state
+ | Returnstate:
+ forall (stack: list stackframe) (rs: locset) (m: mem),
+ state.
-Inductive exec_instr: function -> val ->
- code -> locset -> mem -> trace ->
- code -> locset -> mem -> Prop :=
+(** [parent_locset cs] returns the mapping of values for locations
+ of the caller function. *)
+
+Definition parent_locset (stack: list stackframe) : locset :=
+ match stack with
+ | nil => Locmap.init Vundef
+ | Stackframe f sp ls c :: stack' => ls
+ end.
+
+Inductive step: state -> trace -> state -> Prop :=
| exec_Lgetstack:
- forall f sp sl r b rs m,
- exec_instr f sp (Lgetstack sl r :: b) rs m
- E0 b (Locmap.set (R r) (rs (S sl)) rs) m
+ forall s f sp sl r b rs m,
+ step (State s f sp (Lgetstack sl r :: b) rs m)
+ E0 (State s f sp b (Locmap.set (R r) (rs (S sl)) rs) m)
| exec_Lsetstack:
- forall f sp r sl b rs m,
- exec_instr f sp (Lsetstack r sl :: b) rs m
- E0 b (Locmap.set (S sl) (rs (R r)) rs) m
+ forall s f sp r sl b rs m,
+ step (State s f sp (Lsetstack r sl :: b) rs m)
+ E0 (State s f sp b (Locmap.set (S sl) (rs (R r)) rs) m)
| exec_Lop:
- forall f sp op args res b rs m v,
- eval_operation ge sp op (reglist args rs) = Some v ->
- exec_instr f sp (Lop op args res :: b) rs m
- E0 b (Locmap.set (R res) v rs) m
+ forall s f sp op args res b rs m v,
+ eval_operation ge sp op (reglist rs args) m = Some v ->
+ step (State s f sp (Lop op args res :: b) rs m)
+ E0 (State s f sp b (Locmap.set (R res) v rs) m)
| exec_Lload:
- forall f sp chunk addr args dst b rs m a v,
- eval_addressing ge sp addr (reglist args rs) = Some a ->
+ forall s f sp chunk addr args dst b rs m a v,
+ eval_addressing ge sp addr (reglist rs args) = Some a ->
loadv chunk m a = Some v ->
- exec_instr f sp (Lload chunk addr args dst :: b) rs m
- E0 b (Locmap.set (R dst) v rs) m
+ step (State s f sp (Lload chunk addr args dst :: b) rs m)
+ E0 (State s f sp b (Locmap.set (R dst) v rs) m)
| exec_Lstore:
- forall f sp chunk addr args src b rs m m' a,
- eval_addressing ge sp addr (reglist args rs) = Some a ->
+ forall s f sp chunk addr args src b rs m m' a,
+ eval_addressing ge sp addr (reglist rs args) = Some a ->
storev chunk m a (rs (R src)) = Some m' ->
- exec_instr f sp (Lstore chunk addr args src :: b) rs m
- E0 b rs m'
+ step (State s f sp (Lstore chunk addr args src :: b) rs m)
+ E0 (State s f sp b rs m')
| exec_Lcall:
- forall f sp sig ros b rs m t f' rs' m',
+ forall s f sp sig ros b rs m f',
find_function ros rs = Some f' ->
sig = funsig f' ->
- exec_function f' rs m t rs' m' ->
- exec_instr f sp (Lcall sig ros :: b) rs m
- t b (return_regs rs rs') m'
+ step (State s f sp (Lcall sig ros :: b) rs m)
+ E0 (Callstate (Stackframe f sp rs b:: s) f' rs m)
+ | exec_Ltailcall:
+ forall s f stk sig ros b rs m f',
+ find_function ros rs = Some f' ->
+ sig = funsig f' ->
+ step (State s f (Vptr stk Int.zero) (Ltailcall sig ros :: b) rs m)
+ E0 (Callstate s f' (return_regs (parent_locset s) rs) (Mem.free m stk))
| exec_Lalloc:
- forall f sp b rs m sz m' blk,
+ forall s f sp b rs m sz m' blk,
rs (R Conventions.loc_alloc_argument) = Vint sz ->
Mem.alloc m 0 (Int.signed sz) = (m', blk) ->
- exec_instr f sp (Lalloc :: b) rs m
- E0 b (Locmap.set (R Conventions.loc_alloc_result)
- (Vptr blk Int.zero) rs) m'
+ step (State s f sp (Lalloc :: b) rs m)
+ E0 (State s f sp b
+ (Locmap.set (R Conventions.loc_alloc_result)
+ (Vptr blk Int.zero) rs)
+ m')
| exec_Llabel:
- forall f sp lbl b rs m,
- exec_instr f sp (Llabel lbl :: b) rs m
- E0 b rs m
+ forall s f sp lbl b rs m,
+ step (State s f sp (Llabel lbl :: b) rs m)
+ E0 (State s f sp b rs m)
| exec_Lgoto:
- forall f sp lbl b rs m b',
+ forall s f sp lbl b rs m b',
find_label lbl f.(fn_code) = Some b' ->
- exec_instr f sp (Lgoto lbl :: b) rs m
- E0 b' rs m
+ step (State s f sp (Lgoto lbl :: b) rs m)
+ E0 (State s f sp b' rs m)
| exec_Lcond_true:
- forall f sp cond args lbl b rs m b',
- eval_condition cond (reglist args rs) = Some true ->
+ forall s f sp cond args lbl b rs m b',
+ eval_condition cond (reglist rs args) m = Some true ->
find_label lbl f.(fn_code) = Some b' ->
- exec_instr f sp (Lcond cond args lbl :: b) rs m
- E0 b' rs m
+ step (State s f sp (Lcond cond args lbl :: b) rs m)
+ E0 (State s f sp b' rs m)
| exec_Lcond_false:
- forall f sp cond args lbl b rs m,
- eval_condition cond (reglist args rs) = Some false ->
- exec_instr f sp (Lcond cond args lbl :: b) rs m
- E0 b rs m
-
-with exec_instrs: function -> val ->
- code -> locset -> mem -> trace ->
- code -> locset -> mem -> Prop :=
- | exec_refl:
- forall f sp b rs m,
- exec_instrs f sp b rs m E0 b rs m
- | exec_one:
- forall f sp b1 rs1 m1 t b2 rs2 m2,
- exec_instr f sp b1 rs1 m1 t b2 rs2 m2 ->
- exec_instrs f sp b1 rs1 m1 t b2 rs2 m2
- | exec_trans:
- forall f sp b1 rs1 m1 t1 b2 rs2 m2 t2 b3 rs3 m3 t,
- exec_instrs f sp b1 rs1 m1 t1 b2 rs2 m2 ->
- exec_instrs f sp b2 rs2 m2 t2 b3 rs3 m3 ->
- t = t1 ** t2 ->
- exec_instrs f sp b1 rs1 m1 t b3 rs3 m3
-
-with exec_function: fundef -> locset -> mem -> trace -> locset -> mem -> Prop :=
- | exec_funct_internal:
- forall f rs m t m1 stk rs2 m2 b,
- alloc m 0 f.(fn_stacksize) = (m1, stk) ->
- exec_instrs f (Vptr stk Int.zero)
- f.(fn_code) (call_regs rs) m1
- t (Lreturn :: b) rs2 m2 ->
- exec_function (Internal f) rs m t rs2 (free m2 stk)
- | exec_funct_external:
- forall ef args res rs1 rs2 m t,
+ forall s f sp cond args lbl b rs m,
+ eval_condition cond (reglist rs args) m = Some false ->
+ step (State s f sp (Lcond cond args lbl :: b) rs m)
+ E0 (State s f sp b rs m)
+ | exec_Lreturn:
+ forall s f stk b rs m,
+ step (State s f (Vptr stk Int.zero) (Lreturn :: b) rs m)
+ E0 (Returnstate s (return_regs (parent_locset s) rs) (Mem.free m stk))
+ | exec_function_internal:
+ forall s f rs m m' stk,
+ alloc m 0 f.(fn_stacksize) = (m', stk) ->
+ step (Callstate s (Internal f) rs m)
+ E0 (State s f (Vptr stk Int.zero) f.(fn_code) (call_regs rs) m')
+ | exec_function_external:
+ forall s ef args res rs1 rs2 m t,
event_match ef args t res ->
args = List.map rs1 (Conventions.loc_arguments ef.(ef_sig)) ->
rs2 = Locmap.set (R (Conventions.loc_result ef.(ef_sig))) res rs1 ->
- exec_function (External ef) rs1 m t rs2 m.
-
-Scheme exec_instr_ind3 := Minimality for exec_instr Sort Prop
- with exec_instrs_ind3 := Minimality for exec_instrs Sort Prop
- with exec_function_ind3 := Minimality for exec_function Sort Prop.
+ step (Callstate s (External ef) rs1 m)
+ t (Returnstate s rs2 m)
+ | exec_return:
+ forall s f sp rs0 c rs m,
+ step (Returnstate (Stackframe f sp rs0 c :: s) rs m)
+ E0 (State s f sp c rs m).
End RELSEM.
-Definition exec_program (p: program) (t: trace) (r: val) : Prop :=
- let ge := Genv.globalenv p in
- let m0 := Genv.init_mem p in
- exists b, exists f, exists rs, exists m,
- Genv.find_symbol ge p.(prog_main) = Some b /\
- Genv.find_funct_ptr ge b = Some f /\
- funsig f = mksignature nil (Some Tint) /\
- exec_function ge f (Locmap.init Vundef) m0 t rs m /\
- rs (R (Conventions.loc_result (funsig f))) = r.
+Inductive initial_state (p: program): state -> Prop :=
+ | initial_state_intro: forall b f,
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ Genv.find_symbol ge p.(prog_main) = Some b ->
+ Genv.find_funct_ptr ge b = Some f ->
+ funsig f = mksignature nil (Some Tint) ->
+ initial_state p (Callstate nil f (Locmap.init Vundef) m0).
+
+Inductive final_state: state -> int -> Prop :=
+ | final_state_intro: forall rs m r,
+ rs (R R3) = Vint r ->
+ final_state (Returnstate nil rs m) r.
+Definition exec_program (p: program) (beh: program_behavior) : Prop :=
+ program_behaves step (initial_state p) final_state (Genv.globalenv p) beh.
diff --git a/backend/Linearize.v b/backend/Linearize.v
index 3151628c27858ccd2e3c7d302b0a01fbe03823de..305473ba775f72a14c2cf4b5b7489925b7e9cd7c 100644
--- a/backend/Linearize.v
+++ b/backend/Linearize.v
@@ -1,5 +1,5 @@
(** Linearization of the control-flow graph:
- translation from LTL to Linear *)
+ translation from LTL to LTLin *)
Require Import Coqlib.
Require Import Maps.
@@ -9,24 +9,24 @@ Require Import Globalenvs.
Require Import Op.
Require Import Locations.
Require Import LTL.
-Require Import Linear.
+Require Import LTLin.
Require Import Kildall.
Require Import Lattice.
-(** To translate from LTL to Linear, we must layout the basic blocks
+(** To translate from LTL to LTLin, we must lay out the basic blocks
of the LTL control-flow graph in some linear order, and insert
explicit branches and conditional branches to make sure that
each basic block jumps to its successors as prescribed by the
LTL control-flow graph. However, branches are not necessary
- if the fall-through behaviour of Linear instructions already
+ if the fall-through behaviour of LTLin instructions already
implements the desired flow of control. For instance,
- consider the two LTL basic blocks
+ consider the two LTL instructions
<<
- L1: Bop op args res (Bgoto L2)
+ L1: Lop op args res L2
L2: ...
>>
- If the blocks [L1] and [L2] are laid out consecutively in the Linear
- code, we can generate the following Linear code:
+ If the instructions [L1] and [L2] are laid out consecutively in the LTLin
+ code, we can generate the following LTLin code:
<<
L1: Lop op args res
L2: ...
@@ -49,19 +49,13 @@ Require Import Lattice.
- Choosing an order for the basic blocks. This returns an enumeration
of CFG nodes stating that the basic blocks must be laid out in
the order shown in the list.
-- Generate naive Linear code where each basic block branches explicitly
- to its successors, even if one of these successors is the next basic
- block.
-- Simplify the naive Linear code, removing unconditional branches to
- a label that immediately follows:
-<<
- ... ...
- Igoto L1; becomes L1: ...
- L1: ...
->>
+- Generate LTLin code where each basic block branches explicitly
+ to its successors, except if one of these successors is the
+ immediately following instruction.
+
The beauty of this approach is that correct code is generated
under surprisingly weak hypotheses on the enumeration of
- CFG nodes: it suffices that every reachable basic block occurs
+ CFG nodes: it suffices that every reachable instruction occurs
exactly once in the enumeration. While the enumeration heuristic we use
is quite trivial, it is easy to implement more sophisticated
trace picking heuristics: as long as they satisfy the property above,
@@ -73,10 +67,10 @@ Require Import Lattice.
(** * Determination of the order of basic blocks *)
(** We first compute a mapping from CFG nodes to booleans,
- indicating whether a CFG basic block is reachable or not.
+ indicating whether a CFG instruction is reachable or not.
This computation is a trivial forward dataflow analysis
where the transfer function is the identity: the successors
- of a reachable block are reachable, by the very
+ of a reachable instruction are reachable, by the very
definition of reachability. *)
Module DS := Dataflow_Solver(LBoolean)(NodeSetForward).
@@ -84,7 +78,7 @@ Module DS := Dataflow_Solver(LBoolean)(NodeSetForward).
Definition reachable_aux (f: LTL.function) : option (PMap.t bool) :=
DS.fixpoint
(successors f)
- (Psucc f.(fn_entrypoint))
+ (f.(fn_nextpc))
(fun pc r => r)
((f.(fn_entrypoint), true) :: nil).
@@ -108,15 +102,17 @@ Definition enumerate (f: LTL.function) : list node :=
let reach := reachable f in
positive_rec (list node) nil
(fun pc nodes => if reach!!pc then pc :: nodes else nodes)
- (Psucc f.(fn_entrypoint)).
+ f.(fn_nextpc).
-(** * Translation from LTL to Linear *)
+(** * Translation from LTL to LTLin *)
(** We now flatten the structure of the CFG graph, laying out
- basic blocks consecutively in the order computed by [enumerate],
- and inserting a branch at the end of every basic block.
+ LTL instructions consecutively in the order computed by [enumerate],
+ and inserting branches to the labels of sucessors if necessary.
+ Whether to insert a branch or not is determined by
+ the [starts_with] function below.
- For blocks ending in a conditional branch [Bcond cond args s1 s2],
+ For LTL conditional branches [Lcond cond args s1 s2],
we have two possible translations:
<<
Lcond cond args s1; or Lcond (not cond) args s2;
@@ -124,8 +120,8 @@ Definition enumerate (f: LTL.function) : list node :=
>>
We favour the first translation if [s2] is the label of the
next instruction, and the second if [s1] is the label of the
- next instruction, thus exhibiting more opportunities for
- fall-through optimization later. *)
+ next instruction, thus avoiding the insertion of a redundant [Lgoto]
+ instruction. *)
Fixpoint starts_with (lbl: label) (k: code) {struct k} : bool :=
match k with
@@ -133,35 +129,35 @@ Fixpoint starts_with (lbl: label) (k: code) {struct k} : bool :=
| _ => false
end.
-Fixpoint linearize_block (b: block) (k: code) {struct b} : code :=
+Definition add_branch (s: label) (k: code) : code :=
+ if starts_with s k then k else Lgoto s :: k.
+
+Definition linearize_instr (b: LTL.instruction) (k: code) : code :=
match b with
- | Bgetstack s r b =>
- Lgetstack s r :: linearize_block b k
- | Bsetstack r s b =>
- Lsetstack r s :: linearize_block b k
- | Bop op args res b =>
- Lop op args res :: linearize_block b k
- | Bload chunk addr args dst b =>
- Lload chunk addr args dst :: linearize_block b k
- | Bstore chunk addr args src b =>
- Lstore chunk addr args src :: linearize_block b k
- | Bcall sig ros b =>
- Lcall sig ros :: linearize_block b k
- | Balloc b =>
- Lalloc :: linearize_block b k
- | Bgoto s =>
- Lgoto s :: k
- | Bcond cond args s1 s2 =>
+ | LTL.Lnop s =>
+ add_branch s k
+ | LTL.Lop op args res s =>
+ Lop op args res :: add_branch s k
+ | LTL.Lload chunk addr args dst s =>
+ Lload chunk addr args dst :: add_branch s k
+ | LTL.Lstore chunk addr args src s =>
+ Lstore chunk addr args src :: add_branch s k
+ | LTL.Lcall sig ros args res s =>
+ Lcall sig ros args res :: add_branch s k
+ | LTL.Ltailcall sig ros args =>
+ Ltailcall sig ros args :: k
+ | LTL.Lalloc arg res s =>
+ Lalloc arg res :: add_branch s k
+ | LTL.Lcond cond args s1 s2 =>
if starts_with s1 k then
- Lcond (negate_condition cond) args s2 :: Lgoto s1 :: k
+ Lcond (negate_condition cond) args s2 :: add_branch s1 k
else
- Lcond cond args s1 :: Lgoto s2 :: k
- | Breturn =>
- Lreturn :: k
+ Lcond cond args s1 :: add_branch s2 k
+ | LTL.Lreturn or =>
+ Lreturn or :: k
end.
-(* Linearize a function body according to an enumeration of its
- nodes. *)
+(** Linearize a function body according to an enumeration of its nodes. *)
Fixpoint linearize_body (f: LTL.function) (enum: list node)
{struct enum} : code :=
@@ -170,47 +166,21 @@ Fixpoint linearize_body (f: LTL.function) (enum: list node)
| pc :: rem =>
match f.(LTL.fn_code)!pc with
| None => linearize_body f rem
- | Some b => Llabel pc :: linearize_block b (linearize_body f rem)
+ | Some b => Llabel pc :: linearize_instr b (linearize_body f rem)
end
end.
-Definition linearize_function (f: LTL.function) : Linear.function :=
+(** * Entry points for code linearization *)
+
+Definition transf_function (f: LTL.function) : LTLin.function :=
mkfunction
(LTL.fn_sig f)
+ (LTL.fn_params f)
(LTL.fn_stacksize f)
- (linearize_body f (enumerate f)).
-
-(** * Cleanup of the linearized code *)
-
-(** We now eliminate [Lgoto] instructions that branch to an
- immediately following label: these are redundant, as the fall-through
- behaviour obtained by removing the [Lgoto] instruction is
- semantically equivalent. *)
-
-Fixpoint cleanup_code (c: code) {struct c} : code :=
- match c with
- | nil => nil
- | Lgoto lbl :: c' =>
- if starts_with lbl c'
- then cleanup_code c'
- else Lgoto lbl :: cleanup_code c'
- | i :: c' =>
- i :: cleanup_code c'
- end.
-
-Definition cleanup_function (f: Linear.function) : Linear.function :=
- mkfunction
- (fn_sig f)
- (fn_stacksize f)
- (cleanup_code f.(fn_code)).
-
-(** * Entry points for code linearization *)
-
-Definition transf_function (f: LTL.function) : Linear.function :=
- cleanup_function (linearize_function f).
+ (add_branch (LTL.fn_entrypoint f) (linearize_body f (enumerate f))).
-Definition transf_fundef (f: LTL.fundef) : Linear.fundef :=
+Definition transf_fundef (f: LTL.fundef) : LTLin.fundef :=
AST.transf_fundef transf_function f.
-Definition transf_program (p: LTL.program) : Linear.program :=
+Definition transf_program (p: LTL.program) : LTLin.program :=
transform_program transf_fundef p.
diff --git a/backend/Linearizeproof.v b/backend/Linearizeproof.v
index 5937fc3434ef3025f19996c749e4a47b921c1f44..c72990858a6fc90a0bbe5cbec26e375ded78b666 100644
--- a/backend/Linearizeproof.v
+++ b/backend/Linearizeproof.v
@@ -8,10 +8,12 @@ Require Import Values.
Require Import Mem.
Require Import Events.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Op.
Require Import Locations.
Require Import LTL.
-Require Import Linear.
+Require Import LTLtyping.
+Require Import LTLin.
Require Import Linearize.
Require Import Lattice.
@@ -46,6 +48,18 @@ Proof.
destruct f; reflexivity.
Qed.
+Lemma find_function_translated:
+ forall ros ls f,
+ LTL.find_function ge ros ls = Some f ->
+ find_function tge ros ls = Some (transf_fundef f).
+Proof.
+ intros until f. destruct ros; simpl.
+ intro. apply functions_translated; auto.
+ rewrite symbols_preserved. destruct (Genv.find_symbol ge i).
+ apply function_ptr_translated; auto.
+ congruence.
+Qed.
+
(** * Correctness of reachability analysis *)
(** The entry point of the function is reachable. *)
@@ -62,11 +76,10 @@ Proof.
intros. apply PMap.gi.
Qed.
-(** The successors of a reachable basic block are reachable. *)
+(** The successors of a reachable instruction are reachable. *)
Lemma reachable_successors:
forall f pc pc',
- f.(LTL.fn_code)!pc <> None ->
In pc' (successors f pc) ->
(reachable f)!!pc = true ->
(reachable f)!!pc' = true.
@@ -74,51 +87,19 @@ Proof.
intro f. unfold reachable.
caseEq (reachable_aux f).
unfold reachable_aux. intro reach; intros.
+ elim (LTL.fn_code_wf f pc); intro.
assert (LBoolean.ge reach!!pc' reach!!pc).
change (reach!!pc) with ((fun pc r => r) pc (reach!!pc)).
- eapply DS.fixpoint_solution. eexact H.
- elim (fn_code_wf f pc); intro. auto. contradiction.
- auto.
+ eapply DS.fixpoint_solution. eexact H. auto. auto.
elim H3; intro. congruence. auto.
+ unfold successors in H0. rewrite H2 in H0. contradiction.
intros. apply PMap.gi.
Qed.
-(* If we have a valid LTL transition from [pc] to [pc'], and
- [pc] is reachable, then [pc'] is reachable. *)
-
-Lemma reachable_correct_1:
- forall f sp pc rs m t pc' rs' m' b,
- f.(LTL.fn_code)!pc = Some b ->
- exec_block ge sp b rs m t (Cont pc') rs' m' ->
- (reachable f)!!pc = true ->
- (reachable f)!!pc' = true.
-Proof.
- intros. apply reachable_successors with pc; auto.
- congruence.
- eapply successors_correct; eauto.
-Qed.
-
-Lemma reachable_correct_2:
- forall c sp pc rs m t out rs' m',
- exec_blocks ge c sp pc rs m t out rs' m' ->
- forall f pc',
- c = f.(LTL.fn_code) ->
- out = Cont pc' ->
- (reachable f)!!pc = true ->
- (reachable f)!!pc' = true.
-Proof.
- induction 1; intros.
- congruence.
- eapply reachable_correct_1. rewrite <- H1; eauto.
- subst out; eauto. auto.
- auto.
-Qed.
-
(** * Properties of node enumeration *)
(** An enumeration of CFG nodes is correct if the following conditions hold:
- All nodes for reachable basic blocks must be in the list.
-- The function entry point is the first element in the list.
- The list is without repetition (so that no code duplication occurs).
We prove that our [enumerate] function satisfies all three. *)
@@ -131,10 +112,10 @@ Lemma enumerate_complete:
Proof.
intros.
assert (forall p,
- Plt p (Psucc f.(fn_entrypoint)) ->
+ Plt p f.(fn_nextpc) ->
(reachable f)!!p = true ->
In p (enumerate f)).
- unfold enumerate. pattern (Psucc (fn_entrypoint f)).
+ unfold enumerate. pattern (fn_nextpc f).
apply positive_Peano_ind.
intros. compute in H1. destruct p; discriminate.
intros. rewrite positive_rec_succ. elim (Plt_succ_inv _ _ H2); intro.
@@ -143,27 +124,15 @@ Proof.
elim (LTL.fn_code_wf f pc); intro. auto. congruence.
Qed.
-Lemma enumerate_head:
- forall f, exists l, enumerate f = f.(LTL.fn_entrypoint) :: l.
-Proof.
- intro. unfold enumerate. rewrite positive_rec_succ.
- rewrite reachable_entrypoint.
- exists (positive_rec (list node) nil
- (fun (pc : positive) (nodes : list node) =>
- if (reachable f) !! pc then pc :: nodes else nodes)
- (fn_entrypoint f) ).
- auto.
-Qed.
-
Lemma enumerate_norepet:
forall f, list_norepet (enumerate f).
Proof.
intro.
- unfold enumerate. pattern (Psucc (fn_entrypoint f)).
+ unfold enumerate. pattern (fn_nextpc f).
apply positive_Peano_ind.
rewrite positive_rec_base. constructor.
intros. rewrite positive_rec_succ.
- case (reachable f)!!x. auto.
+ case (reachable f)!!x.
constructor.
assert (forall y,
In y (positive_rec
@@ -183,9 +152,9 @@ Proof.
auto.
Qed.
-(** * Correctness of the cleanup pass *)
+(** * Properties related to labels *)
-(** If labels are globally unique and the Linear code [c] contains
+(** If labels are globally unique and the LTLin code [c] contains
a subsequence [Llabel lbl :: c1], [find_label lbl c] returns [c1].
*)
@@ -196,27 +165,6 @@ Fixpoint unique_labels (c: code) : Prop :=
| i :: c => unique_labels c
end.
-Inductive is_tail: code -> code -> Prop :=
- | is_tail_refl:
- forall c, is_tail c c
- | is_tail_cons:
- forall i c1 c2, is_tail c1 c2 -> is_tail c1 (i :: c2).
-
-Lemma is_tail_in:
- forall i c1 c2, is_tail (i :: c1) c2 -> In i c2.
-Proof.
- induction c2; simpl; intros.
- inversion H.
- inversion H. tauto. right; auto.
-Qed.
-
-Lemma is_tail_cons_left:
- forall i c1 c2, is_tail (i :: c1) c2 -> is_tail c1 c2.
-Proof.
- induction c2; intros; inversion H.
- constructor. constructor. constructor. auto.
-Qed.
-
Lemma find_label_unique:
forall lbl c1 c2 c3,
is_tail (Llabel lbl :: c1) c2 ->
@@ -237,163 +185,51 @@ Qed.
(** Correctness of the [starts_with] test. *)
Lemma starts_with_correct:
- forall lbl c1 c2 c3 f sp ls m,
+ forall lbl c1 c2 c3 s f sp ls m,
is_tail c1 c2 ->
unique_labels c2 ->
starts_with lbl c1 = true ->
find_label lbl c2 = Some c3 ->
- exec_instrs tge f sp (cleanup_code c1) ls m
- E0 (cleanup_code c3) ls m.
+ plus step tge (State s f sp c1 ls m)
+ E0 (State s f sp c3 ls m).
Proof.
induction c1.
simpl; intros; discriminate.
simpl starts_with. destruct a; try (intros; discriminate).
- intros. apply exec_trans with E0 (cleanup_code c1) ls m E0.
- simpl.
- constructor. constructor.
+ intros.
+ apply plus_left with E0 (State s f sp c1 ls m) E0.
+ simpl. constructor.
destruct (peq lbl l).
subst l. replace c3 with c1. constructor.
apply find_label_unique with lbl c2; auto.
+ apply plus_star.
apply IHc1 with c2; auto. eapply is_tail_cons_left; eauto.
traceEq.
Qed.
-(** Code cleanup preserves the labeling of the code. *)
-
-Lemma find_label_cleanup_code:
- forall lbl c c',
- find_label lbl c = Some c' ->
- find_label lbl (cleanup_code c) = Some (cleanup_code c').
-Proof.
- induction c.
- simpl. intros; discriminate.
- generalize (is_label_correct lbl a).
- simpl find_label. case (is_label lbl a); intro.
- subst a. intros. injection H; intros. subst c'.
- simpl. rewrite peq_true. auto.
- intros. destruct a; auto.
- simpl. rewrite peq_false. auto.
- congruence.
- case (starts_with l c). auto. simpl. auto.
-Qed.
-
-(** One transition in the original Linear code corresponds to zero
- or one transitions in the cleaned-up code. *)
-
-Lemma cleanup_code_correct_1:
- forall f sp c1 ls1 m1 t c2 ls2 m2,
- exec_instr tge f sp c1 ls1 m1 t c2 ls2 m2 ->
- is_tail c1 f.(fn_code) ->
- unique_labels f.(fn_code) ->
- exec_instrs tge (cleanup_function f) sp
- (cleanup_code c1) ls1 m1
- t (cleanup_code c2) ls2 m2.
-Proof.
- induction 1; simpl; intros;
- try (apply exec_one; econstructor; eauto; fail).
- (* goto *)
- caseEq (starts_with lbl b); intro SW.
- eapply starts_with_correct; eauto.
- eapply is_tail_cons_left; eauto.
- constructor. constructor.
- unfold cleanup_function; simpl.
- apply find_label_cleanup_code. auto.
- (* cond, taken *)
- constructor. apply exec_Lcond_true. auto.
- unfold cleanup_function; simpl.
- apply find_label_cleanup_code. auto.
- (* cond, not taken *)
- constructor. apply exec_Lcond_false. auto.
-Qed.
-
-Lemma is_tail_find_label:
- forall lbl c2 c1,
- find_label lbl c1 = Some c2 -> is_tail c2 c1.
-Proof.
- induction c1; simpl.
- intros; discriminate.
- case (is_label lbl a). intro. injection H; intro. subst c2.
- constructor. constructor.
- intro. constructor. auto.
-Qed.
-
-Lemma is_tail_exec_instr:
- forall f sp c1 ls1 m1 t c2 ls2 m2,
- exec_instr tge f sp c1 ls1 m1 t c2 ls2 m2 ->
- is_tail c1 f.(fn_code) -> is_tail c2 f.(fn_code).
-Proof.
- induction 1; intros;
- try (eapply is_tail_cons_left; eauto; fail).
- eapply is_tail_find_label; eauto.
- eapply is_tail_find_label; eauto.
-Qed.
-
-Lemma is_tail_exec_instrs:
- forall f sp c1 ls1 m1 t c2 ls2 m2,
- exec_instrs tge f sp c1 ls1 m1 t c2 ls2 m2 ->
- is_tail c1 f.(fn_code) -> is_tail c2 f.(fn_code).
-Proof.
- induction 1; intros.
- auto.
- eapply is_tail_exec_instr; eauto.
- auto.
-Qed.
-
-(** Zero, one or several transitions in the original Linear code correspond
- to zero, one or several transitions in the cleaned-up code. *)
-
-Lemma cleanup_code_correct_2:
- forall f sp c1 ls1 m1 t c2 ls2 m2,
- exec_instrs tge f sp c1 ls1 m1 t c2 ls2 m2 ->
- is_tail c1 f.(fn_code) ->
- unique_labels f.(fn_code) ->
- exec_instrs tge (cleanup_function f) sp
- (cleanup_code c1) ls1 m1
- t (cleanup_code c2) ls2 m2.
-Proof.
- induction 1; simpl; intros.
- apply exec_refl.
- eapply cleanup_code_correct_1; eauto.
- apply exec_trans with t1 (cleanup_code b2) rs2 m2 t2.
- auto.
- apply IHexec_instrs2; auto.
- eapply is_tail_exec_instrs; eauto.
- auto.
-Qed.
+(** Connection between [find_label] and linearization. *)
-Lemma cleanup_function_correct:
- forall f ls1 m1 t ls2 m2,
- exec_function tge (Internal f) ls1 m1 t ls2 m2 ->
- unique_labels f.(fn_code) ->
- exec_function tge (Internal (cleanup_function f)) ls1 m1 t ls2 m2.
+Lemma find_label_add_branch:
+ forall lbl k s,
+ find_label lbl (add_branch s k) = find_label lbl k.
Proof.
- intros. inversion H; subst.
- generalize (cleanup_code_correct_2 _ _ _ _ _ _ _ _ _ H3 (is_tail_refl _) H0).
- simpl. intro.
- econstructor; eauto.
+ intros. unfold add_branch. destruct (starts_with s k); auto.
Qed.
-(** * Properties of linearized code *)
-
-(** We now state useful properties of the Linear code generated by
- the naive LTL-to-Linear translation. *)
-
-(** Connection between [find_label] and linearization. *)
-
-Lemma find_label_lin_block:
+Lemma find_label_lin_instr:
forall lbl k b,
- find_label lbl (linearize_block b k) = find_label lbl k.
+ find_label lbl (linearize_instr b k) = find_label lbl k.
Proof.
+ intros lbl k. generalize (find_label_add_branch lbl k); intro.
induction b; simpl; auto.
- case (starts_with n k); reflexivity.
+ case (starts_with n k); simpl; auto.
Qed.
Lemma find_label_lin_rec:
forall f enum pc b,
In pc enum ->
f.(LTL.fn_code)!pc = Some b ->
- exists k,
- find_label pc (linearize_body f enum) = Some (linearize_block b k).
+ exists k, find_label pc (linearize_body f enum) = Some (linearize_instr b k).
Proof.
induction enum; intros.
elim H.
@@ -403,7 +239,7 @@ Proof.
assert (In pc enum). simpl in H. tauto.
elim (IHenum pc b H1 H0). intros k FIND.
exists k. simpl. destruct (LTL.fn_code f)!a.
- simpl. rewrite peq_false. rewrite find_label_lin_block. auto. auto.
+ simpl. rewrite peq_false. rewrite find_label_lin_instr. auto. auto.
auto.
Qed.
@@ -412,20 +248,56 @@ Lemma find_label_lin:
f.(LTL.fn_code)!pc = Some b ->
(reachable f)!!pc = true ->
exists k,
- find_label pc (fn_code (linearize_function f)) = Some (linearize_block b k).
+ find_label pc (fn_code (transf_function f)) = Some (linearize_instr b k).
Proof.
- intros. unfold linearize_function; simpl. apply find_label_lin_rec.
+ intros. unfold transf_function; simpl.
+ rewrite find_label_add_branch. apply find_label_lin_rec.
eapply enumerate_complete; eauto. auto.
Qed.
+Lemma find_label_lin_inv:
+ forall f pc b k ,
+ f.(LTL.fn_code)!pc = Some b ->
+ (reachable f)!!pc = true ->
+ find_label pc (fn_code (transf_function f)) = Some k ->
+ exists k', k = linearize_instr b k'.
+Proof.
+ intros. exploit find_label_lin; eauto. intros [k' FIND].
+ exists k'. congruence.
+Qed.
+
+Lemma find_label_lin_succ:
+ forall f s,
+ valid_successor f s ->
+ (reachable f)!!s = true ->
+ exists k,
+ find_label s (fn_code (transf_function f)) = Some k.
+Proof.
+ intros. destruct H as [i AT].
+ exploit find_label_lin; eauto. intros [k FIND].
+ exists (linearize_instr i k); auto.
+Qed.
+
(** Unique label property for linearized code. *)
-Lemma label_in_lin_block:
+Lemma label_in_add_branch:
+ forall lbl s k,
+ In (Llabel lbl) (add_branch s k) -> In (Llabel lbl) k.
+Proof.
+ intros until k; unfold add_branch.
+ destruct (starts_with s k); simpl; intuition congruence.
+Qed.
+
+Lemma label_in_lin_instr:
forall lbl k b,
- In (Llabel lbl) (linearize_block b k) -> In (Llabel lbl) k.
+ In (Llabel lbl) (linearize_instr b k) -> In (Llabel lbl) k.
Proof.
- induction b; simpl; try (intuition congruence).
- case (starts_with n k); simpl; intuition congruence.
+ induction b; simpl; intros;
+ try (apply label_in_add_branch with n; intuition congruence);
+ try (intuition congruence).
+ destruct (starts_with n k); simpl in H.
+ apply label_in_add_branch with n; intuition congruence.
+ apply label_in_add_branch with n0; intuition congruence.
Qed.
Lemma label_in_lin_rec:
@@ -436,16 +308,24 @@ Proof.
simpl; auto.
simpl. destruct (LTL.fn_code f)!a.
simpl. intros [A|B]. left; congruence.
- right. apply IHenum. eapply label_in_lin_block; eauto.
+ right. apply IHenum. eapply label_in_lin_instr; eauto.
intro; right; auto.
Qed.
-Lemma unique_labels_lin_block:
+Lemma unique_labels_add_branch:
+ forall lbl k,
+ unique_labels k -> unique_labels (add_branch lbl k).
+Proof.
+ intros; unfold add_branch.
+ destruct (starts_with lbl k); simpl; intuition.
+Qed.
+
+Lemma unique_labels_lin_instr:
forall k b,
- unique_labels k -> unique_labels (linearize_block b k).
+ unique_labels k -> unique_labels (linearize_instr b k).
Proof.
- induction b; simpl; auto.
- case (starts_with n k); simpl; auto.
+ induction b; intro; simpl; auto; try (apply unique_labels_add_branch; auto).
+ case (starts_with n k); simpl; apply unique_labels_add_branch; auto.
Qed.
Lemma unique_labels_lin_rec:
@@ -458,268 +338,339 @@ Proof.
intro. simpl. destruct (LTL.fn_code f)!a.
simpl. split. red. intro. inversion H. elim H3.
apply label_in_lin_rec with f.
- apply label_in_lin_block with b. auto.
- apply unique_labels_lin_block. apply IHenum. inversion H; auto.
+ apply label_in_lin_instr with i. auto.
+ apply unique_labels_lin_instr. apply IHenum. inversion H; auto.
apply IHenum. inversion H; auto.
Qed.
-Lemma unique_labels_lin_function:
+Lemma unique_labels_transf_function:
forall f,
- unique_labels (fn_code (linearize_function f)).
+ unique_labels (fn_code (transf_function f)).
Proof.
- intros. unfold linearize_function; simpl.
+ intros. unfold transf_function; simpl.
+ apply unique_labels_add_branch.
apply unique_labels_lin_rec. apply enumerate_norepet.
Qed.
-(** * Correctness of linearization *)
+(** Correctness of [add_branch]. *)
+
+Lemma is_tail_find_label:
+ forall lbl c2 c1,
+ find_label lbl c1 = Some c2 -> is_tail c2 c1.
+Proof.
+ induction c1; simpl.
+ intros; discriminate.
+ case (is_label lbl a). intro. injection H; intro. subst c2.
+ constructor. constructor.
+ intro. constructor. auto.
+Qed.
-(** The outcome of an LTL [exec_block] or [exec_blocks] execution
- is valid if it corresponds to a reachable, existing basic block.
- All outcomes occurring in an LTL program execution are actually
- valid, but we will prove that along with the main simulation proof. *)
+Lemma is_tail_add_branch:
+ forall lbl c1 c2, is_tail (add_branch lbl c1) c2 -> is_tail c1 c2.
+Proof.
+ intros until c2. unfold add_branch. destruct (starts_with lbl c1).
+ auto. eauto with coqlib.
+Qed.
-Definition valid_outcome (f: LTL.function) (out: outcome) :=
- match out with
- | Cont s =>
- (reachable f)!!s = true /\ exists b, f.(LTL.fn_code)!s = Some b
- | Return => True
- end.
+Lemma add_branch_correct:
+ forall lbl c k s f sp ls m,
+ is_tail k (transf_function f).(fn_code) ->
+ find_label lbl (transf_function f).(fn_code) = Some c ->
+ plus step tge (State s (transf_function f) sp (add_branch lbl k) ls m)
+ E0 (State s (transf_function f) sp c ls m).
+Proof.
+ intros. unfold add_branch.
+ caseEq (starts_with lbl k); intro SW.
+ eapply starts_with_correct; eauto.
+ apply unique_labels_transf_function.
+ apply plus_one. apply exec_Lgoto. auto.
+Qed.
-(** Auxiliary lemma used to establish the [valid_outcome] property. *)
+(** * Correctness of linearization *)
-Lemma exec_blocks_valid_outcome:
- forall c sp pc ls1 m1 t out ls2 m2,
- exec_blocks ge c sp pc ls1 m1 t out ls2 m2 ->
- forall f,
- c = f.(LTL.fn_code) ->
- (reachable f)!!pc = true ->
- valid_outcome f out ->
- valid_outcome f (Cont pc).
+(** The proof of semantic preservation is a simulation argument
+ based on diagrams of the following form:
+<<
+ st1 --------------- st2
+ | |
+ t| +|t
+ | |
+ v v
+ st1'--------------- st2'
+>>
+ The invariant (horizontal lines above) is the [match_states]
+ predicate defined below. It captures the fact that the flow
+ of data is the same in the source and linearized codes.
+ Moreover, whenever the source state is at node [pc] in its
+ control-flow graph, the transformed state is at a code
+ sequence [c] that starts with the label [pc]. *)
+
+Inductive match_stackframes: LTL.stackframe -> LTLin.stackframe -> Prop :=
+ | match_stackframe_intro:
+ forall res f sp pc ls c,
+ (reachable f)!!pc = true ->
+ valid_successor f pc ->
+ is_tail c (fn_code (transf_function f)) ->
+ wt_function f ->
+ match_stackframes
+ (LTL.Stackframe res f sp ls pc)
+ (LTLin.Stackframe res (transf_function f) sp ls (add_branch pc c)).
+
+Inductive match_states: LTL.state -> LTLin.state -> Prop :=
+ | match_states_intro:
+ forall s f sp pc ls m ts c
+ (STACKS: list_forall2 match_stackframes s ts)
+ (REACH: (reachable f)!!pc = true)
+ (AT: find_label pc (fn_code (transf_function f)) = Some c)
+ (WTF: wt_function f),
+ match_states (LTL.State s f sp pc ls m)
+ (LTLin.State ts (transf_function f) sp c ls m)
+ | match_states_call:
+ forall s f ls m ts,
+ list_forall2 match_stackframes s ts ->
+ wt_fundef f ->
+ match_states (LTL.Callstate s f ls m)
+ (LTLin.Callstate ts (transf_fundef f) ls m)
+ | match_states_return:
+ forall s sig ls m ts,
+ list_forall2 match_stackframes s ts ->
+ match_states (LTL.Returnstate s sig ls m)
+ (LTLin.Returnstate ts sig ls m).
+
+Remark parent_locset_match:
+ forall s ts,
+ list_forall2 match_stackframes s ts ->
+ parent_locset ts = LTL.parent_locset s.
Proof.
- induction 1.
- auto.
- intros. simpl. split. auto. exists b. congruence.
- intros. apply IHexec_blocks1. auto. auto.
- apply IHexec_blocks2. auto.
- eapply reachable_correct_2. eexact H. auto. auto. auto.
- auto.
+ induction 1; simpl; auto. inv H; auto.
Qed.
-(** Correspondence between an LTL outcome and a fragment of generated
- Linear code. *)
-
-Inductive cont_for_outcome: LTL.function -> outcome -> code -> Prop :=
- | co_return:
- forall f k,
- cont_for_outcome f Return (Lreturn :: k)
- | co_goto:
- forall f s k,
- find_label s (linearize_function f).(fn_code) = Some k ->
- cont_for_outcome f (Cont s) k.
-
-(** The simulation properties used in the inductive proof.
- They are parameterized by an LTL execution, and state
- that a matching execution is possible in the generated Linear code. *)
-
-Definition exec_instr_prop
- (sp: val) (b1: block) (ls1: locset) (m1: mem)
- (t: trace) (b2: block) (ls2: locset) (m2: mem) : Prop :=
- forall f k,
- exec_instr tge (linearize_function f) sp
- (linearize_block b1 k) ls1 m1
- t (linearize_block b2 k) ls2 m2.
-
-Definition exec_instrs_prop
- (sp: val) (b1: block) (ls1: locset) (m1: mem)
- (t: trace) (b2: block) (ls2: locset) (m2: mem) : Prop :=
- forall f k,
- exec_instrs tge (linearize_function f) sp
- (linearize_block b1 k) ls1 m1
- t (linearize_block b2 k) ls2 m2.
-
-Definition exec_block_prop
- (sp: val) (b: block) (ls1: locset) (m1: mem)
- (t: trace) (out: outcome) (ls2: locset) (m2: mem): Prop :=
- forall f k,
- valid_outcome f out ->
- exists k',
- exec_instrs tge (linearize_function f) sp
- (linearize_block b k) ls1 m1
- t k' ls2 m2
- /\ cont_for_outcome f out k'.
-
-Definition exec_blocks_prop
- (c: LTL.code) (sp: val) (pc: node) (ls1: locset) (m1: mem)
- (t: trace) (out: outcome) (ls2: locset) (m2: mem): Prop :=
- forall f k,
- c = f.(LTL.fn_code) ->
- (reachable f)!!pc = true ->
- find_label pc (fn_code (linearize_function f)) = Some k ->
- valid_outcome f out ->
- exists k',
- exec_instrs tge (linearize_function f) sp
- k ls1 m1
- t k' ls2 m2
- /\ cont_for_outcome f out k'.
-
-Definition exec_function_prop
- (f: LTL.fundef) (ls1: locset) (m1: mem) (t: trace)
- (ls2: locset) (m2: mem): Prop :=
- exec_function tge (transf_fundef f) ls1 m1 t ls2 m2.
-
-Scheme exec_instr_ind5 := Minimality for LTL.exec_instr Sort Prop
- with exec_instrs_ind5 := Minimality for LTL.exec_instrs Sort Prop
- with exec_block_ind5 := Minimality for LTL.exec_block Sort Prop
- with exec_blocks_ind5 := Minimality for LTL.exec_blocks Sort Prop
- with exec_function_ind5 := Minimality for LTL.exec_function Sort Prop.
-
-(** The obligatory proof by structural induction on the LTL evaluation
- derivation. *)
-
-Lemma transf_function_correct:
- forall f ls1 m1 t ls2 m2,
- LTL.exec_function ge f ls1 m1 t ls2 m2 ->
- exec_function_prop f ls1 m1 t ls2 m2.
+Hypothesis wt_prog: wt_program prog.
+
+Theorem transf_step_correct:
+ forall s1 t s2, LTL.step ge s1 t s2 ->
+ forall s1' (MS: match_states s1 s1'),
+ exists s2', plus LTLin.step tge s1' t s2' /\ match_states s2 s2'.
Proof.
- apply (exec_function_ind5 ge
- exec_instr_prop
- exec_instrs_prop
- exec_block_prop
- exec_blocks_prop
- exec_function_prop);
- intros; red; intros; simpl.
- (* getstack *)
- constructor.
- (* setstack *)
- constructor.
- (* op *)
- constructor. rewrite <- H. apply eval_operation_preserved.
- exact symbols_preserved.
- (* load *)
- apply exec_Lload with a.
- rewrite <- H. apply eval_addressing_preserved.
- exact symbols_preserved.
- auto.
- (* store *)
- apply exec_Lstore with a.
- rewrite <- H. apply eval_addressing_preserved.
- exact symbols_preserved.
- auto.
- (* call *)
- apply exec_Lcall with (transf_fundef f).
- generalize H. destruct ros; simpl.
- intro; apply functions_translated; auto.
- rewrite symbols_preserved. destruct (Genv.find_symbol ge i).
- intro; apply function_ptr_translated; auto. congruence.
- generalize (sig_preserved f). congruence.
- apply H2.
- (* alloc *)
- eapply exec_Lalloc; eauto.
- (* instr_refl *)
- apply exec_refl.
- (* instr_one *)
- apply exec_one. apply H0.
- (* instr_trans *)
- apply exec_trans with t1 (linearize_block b2 k) rs2 m2 t2.
- apply H0. apply H2. auto.
- (* goto *)
- elim H1. intros REACH [b2 AT2].
- generalize (H0 f k). simpl. intro.
- elim (find_label_lin f s b2 AT2 REACH). intros k2 FIND.
- exists (linearize_block b2 k2).
- split.
- eapply exec_trans. eexact H2. constructor. constructor. auto. traceEq.
- constructor. auto.
- (* cond, true *)
- elim H2. intros REACH [b2 AT2].
- elim (find_label_lin f ifso b2 AT2 REACH). intros k2 FIND.
- exists (linearize_block b2 k2).
- split.
- generalize (H0 f k). simpl.
- case (starts_with ifso k); intro.
- eapply exec_trans. eexact H3.
- eapply exec_trans. apply exec_one. apply exec_Lcond_false.
- change false with (negb true). apply eval_negate_condition. auto.
- apply exec_one. apply exec_Lgoto. auto. reflexivity. traceEq.
- eapply exec_trans. eexact H3.
- apply exec_one. apply exec_Lcond_true.
- auto. auto. traceEq.
- constructor; auto.
- (* cond, false *)
- elim H2. intros REACH [b2 AT2].
- elim (find_label_lin f ifnot b2 AT2 REACH). intros k2 FIND.
- exists (linearize_block b2 k2).
- split.
- generalize (H0 f k). simpl.
- case (starts_with ifso k); intro.
- eapply exec_trans. eexact H3.
- apply exec_one. apply exec_Lcond_true.
- change true with (negb false). apply eval_negate_condition. auto.
- auto. traceEq.
- eapply exec_trans. eexact H3.
- eapply exec_trans. apply exec_one. apply exec_Lcond_false. auto.
- apply exec_one. apply exec_Lgoto. auto. reflexivity. traceEq.
- constructor; auto.
- (* return *)
- exists (Lreturn :: k). split.
- exact (H0 f k). constructor.
- (* refl blocks *)
- exists k. split. apply exec_refl. constructor. auto.
- (* one blocks *)
- subst c. elim (find_label_lin f pc b H H3). intros k' FIND.
- assert (k = linearize_block b k'). congruence. subst k.
- elim (H1 f k' H5). intros k'' [EXEC CFO].
- exists k''. tauto.
- (* trans blocks *)
- assert ((reachable f)!!pc2 = true).
- eapply reachable_correct_2. eexact H. auto. auto. auto.
- assert (valid_outcome f (Cont pc2)).
- eapply exec_blocks_valid_outcome; eauto.
- generalize (H0 f k H4 H5 H6 H9). intros [k1 [EX1 CFO2]].
- inversion CFO2.
- generalize (H2 f k1 H4 H8 H12 H7). intros [k2 [EX2 CFO3]].
- exists k2. split. eapply exec_trans; eauto. auto.
- (* internal function -- TA-DA! *)
- assert (REACH0: (reachable f)!!(fn_entrypoint f) = true).
+ induction 1; intros; try (inv MS);
+ try (generalize (wt_instrs _ WTF _ _ H); intro WTI).
+ (* Lnop *)
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ assert (REACH': (reachable f)!!pc' = true).
+ eapply reachable_successors; eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ exploit find_label_lin_succ; eauto. inv WTI; auto. intros [c'' AT'].
+ econstructor; split.
+ eapply add_branch_correct; eauto.
+ eapply is_tail_add_branch. eapply is_tail_find_label. eauto.
+ econstructor; eauto.
+ (* Lop *)
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ assert (REACH': (reachable f)!!pc' = true).
+ eapply reachable_successors; eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ exploit find_label_lin_succ; eauto. inv WTI; auto. intros [c'' AT'].
+ econstructor; split.
+ eapply plus_left'.
+ eapply exec_Lop with (v := v); eauto.
+ rewrite <- H0. apply eval_operation_preserved. exact symbols_preserved.
+ eapply add_branch_correct; eauto.
+ eapply is_tail_add_branch. eapply is_tail_cons_left.
+ eapply is_tail_find_label. eauto.
+ traceEq.
+ econstructor; eauto.
+ (* Lload *)
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ assert (REACH': (reachable f)!!pc' = true).
+ eapply reachable_successors; eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ exploit find_label_lin_succ; eauto. inv WTI; auto. intros [c'' AT'].
+ econstructor; split.
+ eapply plus_left'.
+ eapply exec_Lload; eauto.
+ rewrite <- H0. apply eval_addressing_preserved. exact symbols_preserved.
+ eapply add_branch_correct; eauto.
+ eapply is_tail_add_branch. eapply is_tail_cons_left.
+ eapply is_tail_find_label. eauto.
+ traceEq.
+ econstructor; eauto.
+ (* Lstore *)
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ assert (REACH': (reachable f)!!pc' = true).
+ eapply reachable_successors; eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ exploit find_label_lin_succ; eauto. inv WTI; auto. intros [c'' AT'].
+ econstructor; split.
+ eapply plus_left'.
+ eapply exec_Lstore; eauto.
+ rewrite <- H0. apply eval_addressing_preserved. exact symbols_preserved.
+ eapply add_branch_correct; eauto.
+ eapply is_tail_add_branch. eapply is_tail_cons_left.
+ eapply is_tail_find_label. eauto.
+ traceEq.
+ econstructor; eauto.
+ (* Lcall *)
+ unfold rs1 in *. inv MS. fold rs1.
+ generalize (wt_instrs _ WTF _ _ H); intro WTI.
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ assert (REACH': (reachable f)!!pc' = true).
+ eapply reachable_successors; eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ assert (VALID: valid_successor f pc'). inv WTI; auto.
+ econstructor; split.
+ apply plus_one. eapply exec_Lcall with (f' := transf_fundef f'); eauto.
+ apply find_function_translated; auto.
+ symmetry; apply sig_preserved.
+ econstructor; eauto.
+ constructor; auto. econstructor; eauto.
+ eapply is_tail_add_branch. eapply is_tail_cons_left.
+ eapply is_tail_find_label. eauto.
+ destruct ros; simpl in H0.
+ eapply Genv.find_funct_prop; eauto.
+ destruct (Genv.find_symbol ge i); try discriminate.
+ eapply Genv.find_funct_ptr_prop; eauto.
+
+ (* Ltailcall *)
+ unfold rs2, rs1 in *. inv MS. fold rs1; fold rs2.
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ econstructor; split.
+ apply plus_one. eapply exec_Ltailcall with (f' := transf_fundef f'); eauto.
+ apply find_function_translated; auto.
+ symmetry; apply sig_preserved.
+ rewrite (parent_locset_match _ _ STACKS).
+ econstructor; eauto.
+ destruct ros; simpl in H0.
+ eapply Genv.find_funct_prop; eauto.
+ destruct (Genv.find_symbol ge i); try discriminate.
+ eapply Genv.find_funct_ptr_prop; eauto.
+
+ (* Lalloc *)
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ assert (REACH': (reachable f)!!pc' = true).
+ eapply reachable_successors; eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ exploit find_label_lin_succ; eauto. inv WTI; auto. intros [c'' AT'].
+ econstructor; split.
+ eapply plus_left'.
+ eapply exec_Lalloc; eauto.
+ eapply add_branch_correct; eauto.
+ eapply is_tail_add_branch. eapply is_tail_cons_left.
+ eapply is_tail_find_label. eauto.
+ traceEq.
+ econstructor; eauto.
+ (* Lcond true *)
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ assert (REACH': (reachable f)!!ifso = true).
+ eapply reachable_successors; eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ exploit find_label_lin_succ; eauto. inv WTI; auto. intros [c'' AT'].
+ destruct (starts_with ifso c').
+ econstructor; split.
+ eapply plus_left'.
+ eapply exec_Lcond_false; eauto.
+ change false with (negb true). apply eval_negate_condition; auto.
+ eapply add_branch_correct; eauto.
+ eapply is_tail_add_branch. eapply is_tail_cons_left.
+ eapply is_tail_find_label. eauto.
+ traceEq.
+ econstructor; eauto.
+ econstructor; split.
+ apply plus_one. eapply exec_Lcond_true; eauto.
+ econstructor; eauto.
+ (* Lcond false *)
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ assert (REACH': (reachable f)!!ifnot = true).
+ eapply reachable_successors; eauto.
+ unfold successors; rewrite H; auto with coqlib.
+ exploit find_label_lin_succ; eauto. inv WTI; auto. intros [c'' AT'].
+ destruct (starts_with ifso c').
+ econstructor; split.
+ apply plus_one. eapply exec_Lcond_true; eauto.
+ change true with (negb false). apply eval_negate_condition; auto.
+ econstructor; eauto.
+ econstructor; split.
+ eapply plus_left'.
+ eapply exec_Lcond_false; eauto.
+ eapply add_branch_correct; eauto.
+ eapply is_tail_add_branch. eapply is_tail_cons_left.
+ eapply is_tail_find_label. eauto.
+ traceEq.
+ econstructor; eauto.
+ (* Lreturn *)
+ destruct (find_label_lin_inv _ _ _ _ H REACH AT) as [c' EQ].
+ simpl in EQ. subst c.
+ econstructor; split.
+ apply plus_one. eapply exec_Lreturn; eauto.
+ rewrite (parent_locset_match _ _ STACKS).
+ econstructor; eauto.
+ (* internal function *)
+ assert (REACH: (reachable f)!!(LTL.fn_entrypoint f) = true).
apply reachable_entrypoint.
- assert (VO2: valid_outcome f Return). simpl; auto.
- assert (VO1: valid_outcome f (Cont (fn_entrypoint f))).
- eapply exec_blocks_valid_outcome; eauto.
- assert (exists k, fn_code (linearize_function f) = Llabel f.(fn_entrypoint) :: k).
- unfold linearize_function; simpl.
- elim (enumerate_head f). intros tl EN. rewrite EN.
- simpl. elim VO1. intros REACH [b EQ]. rewrite EQ.
- exists (linearize_block b (linearize_body f tl)). auto.
- elim H2; intros k EQ.
- assert (find_label (fn_entrypoint f) (fn_code (linearize_function f)) =
- Some k).
- rewrite EQ. simpl. rewrite peq_true. auto.
- generalize (H1 f k (refl_equal _) REACH0 H3 VO2).
- intros [k' [EX CO]].
- inversion CO. subst k'.
- unfold transf_function. apply cleanup_function_correct.
- econstructor. eauto. rewrite EQ. eapply exec_trans.
- apply exec_one. constructor. eauto. traceEq.
- apply unique_labels_lin_function.
+ inv H6.
+ exploit find_label_lin_succ; eauto. inv H1; auto. intros [c'' AT'].
+ simpl. econstructor; split.
+ eapply plus_left'.
+ eapply exec_function_internal; eauto.
+ simpl. eapply add_branch_correct.
+ simpl. eapply is_tail_add_branch. constructor. eauto.
+ traceEq.
+ econstructor; eauto.
(* external function *)
+ simpl. econstructor; split.
+ apply plus_one. eapply exec_function_external; eauto.
+ econstructor; eauto.
+ (* return *)
+ inv H4. inv H1.
+ exploit find_label_lin_succ; eauto. intros [c' AT].
+ econstructor; split.
+ eapply plus_left'.
+ eapply exec_return; eauto.
+ eapply add_branch_correct; eauto. traceEq.
econstructor; eauto.
Qed.
-End LINEARIZATION.
+Lemma transf_initial_states:
+ forall st1, LTL.initial_state prog st1 ->
+ exists st2, LTLin.initial_state tprog st2 /\ match_states st1 st2.
+Proof.
+ intros. inversion H.
+ exists (Callstate nil (transf_fundef f) (Locmap.init Vundef) (Genv.init_mem tprog)); split.
+ econstructor; eauto.
+ change (prog_main tprog) with (prog_main prog).
+ rewrite symbols_preserved. eauto.
+ apply function_ptr_translated; auto.
+ rewrite <- H2. apply sig_preserved.
+ replace (Genv.init_mem tprog) with (Genv.init_mem prog).
+ constructor. constructor.
+ eapply Genv.find_funct_ptr_prop; eauto.
+ symmetry. unfold tprog, transf_program. apply Genv.init_mem_transf.
+Qed.
+
+Lemma transf_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 -> LTL.final_state st1 r -> LTLin.final_state st2 r.
+Proof.
+ intros. inv H0. inv H. inv H6. constructor. auto.
+Qed.
Theorem transf_program_correct:
- forall (p: LTL.program) (t: trace) (r: val),
- LTL.exec_program p t r ->
- Linear.exec_program (transf_program p) t r.
+ forall (beh: program_behavior),
+ LTL.exec_program prog beh -> LTLin.exec_program tprog beh.
Proof.
- intros p t r [b [f [ls [m [FIND1 [FIND2 [SIG [EX RES]]]]]]]].
- red. exists b; exists (transf_fundef f); exists ls; exists m.
- split. change (prog_main (transf_program p)) with (prog_main p).
- rewrite symbols_preserved; auto.
- split. apply function_ptr_translated. auto.
- split. generalize (sig_preserved f); congruence.
- split. apply transf_function_correct.
- unfold transf_program. rewrite Genv.init_mem_transf. auto.
- rewrite sig_preserved. exact RES.
+ unfold LTL.exec_program, exec_program; intros.
+ eapply simulation_plus_preservation; eauto.
+ eexact transf_initial_states.
+ eexact transf_final_states.
+ eexact transf_step_correct.
Qed.
+End LINEARIZATION.
diff --git a/backend/Linearizetyping.v b/backend/Linearizetyping.v
index 66926e9a685ff9c28ec694f309e4a7507a585e5e..c930ca52353321a279283bd47d2a65462500bbd6 100644
--- a/backend/Linearizetyping.v
+++ b/backend/Linearizetyping.v
@@ -6,327 +6,72 @@ Require Import AST.
Require Import Op.
Require Import Locations.
Require Import LTL.
-Require Import Linear.
-Require Import Linearize.
Require Import LTLtyping.
-Require Import Lineartyping.
+Require Import LTLin.
+Require Import Linearize.
+Require Import LTLintyping.
Require Import Conventions.
-(** * Validity of resource bounds *)
-
-(** In this section, we show that the resource bounds computed by
- [function_bounds] are valid: all references to callee-save registers
- and stack slots in the code of the function are within those bounds. *)
-
-Section BOUNDS.
-
-Variable f: Linear.function.
-Let b := function_bounds f.
-
-Lemma max_over_list_bound:
- forall (A: Set) (valu: A -> Z) (l: list A) (x: A),
- In x l -> valu x <= max_over_list A valu l.
-Proof.
- intros until x. unfold max_over_list.
- assert (forall c z,
- let f := fold_left (fun x y => Zmax x (valu y)) c z in
- z <= f /\ (In x c -> valu x <= f)).
- induction c; simpl; intros.
- split. omega. tauto.
- elim (IHc (Zmax z (valu a))); intros.
- split. apply Zle_trans with (Zmax z (valu a)). apply Zmax1. auto.
- intro H1; elim H1; intro.
- subst a. apply Zle_trans with (Zmax z (valu x)).
- apply Zmax2. auto. auto.
- intro. elim (H l 0); intros. auto.
-Qed.
-
-Lemma max_over_instrs_bound:
- forall (valu: instruction -> Z) i,
- In i f.(fn_code) -> valu i <= max_over_instrs f valu.
-Proof.
- intros. unfold max_over_instrs. apply max_over_list_bound; auto.
-Qed.
-
-Lemma max_over_regs_of_funct_bound:
- forall (valu: mreg -> Z) i r,
- In i f.(fn_code) -> In r (regs_of_instr i) ->
- valu r <= max_over_regs_of_funct f valu.
-Proof.
- intros. unfold max_over_regs_of_funct.
- apply Zle_trans with (max_over_regs_of_instr valu i).
- unfold max_over_regs_of_instr. apply max_over_list_bound. auto.
- apply max_over_instrs_bound. auto.
-Qed.
-
-Lemma max_over_slots_of_funct_bound:
- forall (valu: slot -> Z) i s,
- In i f.(fn_code) -> In s (slots_of_instr i) ->
- valu s <= max_over_slots_of_funct f valu.
-Proof.
- intros. unfold max_over_slots_of_funct.
- apply Zle_trans with (max_over_slots_of_instr valu i).
- unfold max_over_slots_of_instr. apply max_over_list_bound. auto.
- apply max_over_instrs_bound. auto.
-Qed.
-
-Lemma int_callee_save_bound:
- forall i r,
- In i f.(fn_code) -> In r (regs_of_instr i) ->
- index_int_callee_save r < bound_int_callee_save b.
-Proof.
- intros. apply Zlt_le_trans with (int_callee_save r).
- unfold int_callee_save. omega.
- unfold b, function_bounds, bound_int_callee_save.
- eapply max_over_regs_of_funct_bound; eauto.
-Qed.
-
-Lemma float_callee_save_bound:
- forall i r,
- In i f.(fn_code) -> In r (regs_of_instr i) ->
- index_float_callee_save r < bound_float_callee_save b.
-Proof.
- intros. apply Zlt_le_trans with (float_callee_save r).
- unfold float_callee_save. omega.
- unfold b, function_bounds, bound_float_callee_save.
- eapply max_over_regs_of_funct_bound; eauto.
-Qed.
-
-Lemma int_local_slot_bound:
- forall i ofs,
- In i f.(fn_code) -> In (Local ofs Tint) (slots_of_instr i) ->
- ofs < bound_int_local b.
-Proof.
- intros. apply Zlt_le_trans with (int_local (Local ofs Tint)).
- unfold int_local. omega.
- unfold b, function_bounds, bound_int_local.
- eapply max_over_slots_of_funct_bound; eauto.
-Qed.
-
-Lemma float_local_slot_bound:
- forall i ofs,
- In i f.(fn_code) -> In (Local ofs Tfloat) (slots_of_instr i) ->
- ofs < bound_float_local b.
-Proof.
- intros. apply Zlt_le_trans with (float_local (Local ofs Tfloat)).
- unfold float_local. omega.
- unfold b, function_bounds, bound_float_local.
- eapply max_over_slots_of_funct_bound; eauto.
-Qed.
-
-Lemma outgoing_slot_bound:
- forall i ofs ty,
- In i f.(fn_code) -> In (Outgoing ofs ty) (slots_of_instr i) ->
- ofs + typesize ty <= bound_outgoing b.
-Proof.
- intros. change (ofs + typesize ty) with (outgoing_slot (Outgoing ofs ty)).
- unfold b, function_bounds, bound_outgoing.
- apply Zmax_bound_r. apply Zmax_bound_r.
- eapply max_over_slots_of_funct_bound; eauto.
-Qed.
-
-Lemma size_arguments_bound:
- forall sig ros,
- In (Lcall sig ros) f.(fn_code) ->
- size_arguments sig <= bound_outgoing b.
-Proof.
- intros. change (size_arguments sig) with (outgoing_space (Lcall sig ros)).
- unfold b, function_bounds, bound_outgoing.
- apply Zmax_bound_r. apply Zmax_bound_l.
- apply max_over_instrs_bound; auto.
-Qed.
-
-End BOUNDS.
-
-(** Consequently, all machine registers or stack slots mentioned by one
- of the instructions of function [f] are within bounds. *)
-
-Lemma mreg_is_bounded:
- forall f i r,
- In i f.(fn_code) -> In r (regs_of_instr i) ->
- mreg_bounded f r.
-Proof.
- intros. unfold mreg_bounded.
- case (mreg_type r).
- eapply int_callee_save_bound; eauto.
- eapply float_callee_save_bound; eauto.
-Qed.
-
-Lemma slot_is_bounded:
- forall f i s,
- In i (transf_function f).(fn_code) -> In s (slots_of_instr i) ->
- LTLtyping.slot_bounded f s ->
- slot_bounded (transf_function f) s.
-Proof.
- intros. unfold slot_bounded.
- destruct s.
- destruct t.
- split. exact H1. eapply int_local_slot_bound; eauto.
- split. exact H1. eapply float_local_slot_bound; eauto.
- unfold linearize_function; simpl. exact H1.
- split. exact H1. eapply outgoing_slot_bound; eauto.
-Qed.
-
-(** * Conservation property of the cleanup pass *)
-
-(** We show that the cleanup pass only deletes some [Lgoto] instructions:
- all other instructions present in the output of naive linearization
- are in the cleaned-up code, and all instructions in the cleaned-up code
- are in the output of naive linearization. *)
-
-Lemma cleanup_code_conservation:
- forall i,
- match i with Lgoto _ => False | _ => True end ->
- forall c,
- In i c -> In i (cleanup_code c).
-Proof.
- induction c; simpl.
- auto.
- intro.
- assert (In i (a :: cleanup_code c)).
- elim H0; intro. subst i. auto with coqlib.
- apply in_cons. auto.
- destruct a; auto.
- assert (In i (cleanup_code c)).
- elim H1; intro. subst i. contradiction. auto.
- case (starts_with l c). auto. apply in_cons; auto.
-Qed.
-
-Lemma cleanup_function_conservation:
- forall f i,
- In i (linearize_function f).(fn_code) ->
- match i with Lgoto _ => False | _ => True end ->
- In i (transf_function f).(fn_code).
-Proof.
- intros. unfold transf_function. unfold cleanup_function.
- simpl. simpl in H0. eapply cleanup_code_conservation; eauto.
-Qed.
-
-Lemma cleanup_code_conservation_2:
- forall i c, In i (cleanup_code c) -> In i c.
-Proof.
- induction c; simpl.
- auto.
- assert (In i (a :: cleanup_code c) -> a = i \/ In i c).
- intro. elim H; tauto.
- destruct a; auto.
- case (starts_with l c). auto. auto.
-Qed.
+(** * Type preservation for the linearization pass *)
-Lemma cleanup_function_conservation_2:
- forall f i,
- In i (transf_function f).(fn_code) ->
- In i (linearize_function f).(fn_code).
+Lemma wt_add_instr:
+ forall f i k, wt_instr f i -> wt_code f k -> wt_code f (i :: k).
Proof.
- simpl. intros. eapply cleanup_code_conservation_2; eauto.
+ intros; red; intros. elim H1; intro. subst i0; auto. auto.
Qed.
-(** * Type preservation for the linearization pass *)
-
-Lemma linearize_block_incl:
- forall k b, incl k (linearize_block b k).
+Lemma wt_add_branch:
+ forall f s k, wt_code f k -> wt_code f (add_branch s k).
Proof.
- induction b; simpl; auto with coqlib.
- case (starts_with n k); auto with coqlib.
+ intros; unfold add_branch. destruct (starts_with s k).
+ auto. apply wt_add_instr; auto. constructor.
Qed.
-Lemma wt_linearize_block:
- forall f k,
- (forall i, In i k -> wt_instr (transf_function f) i) ->
- forall b i,
- wt_block f b ->
- incl (linearize_block b k) (linearize_function f).(fn_code) ->
- In i (linearize_block b k) -> wt_instr (transf_function f) i.
+Lemma wt_linearize_instr:
+ forall f instr,
+ LTLtyping.wt_instr f instr ->
+ forall k,
+ wt_code f.(LTL.fn_sig) k ->
+ wt_code f.(LTL.fn_sig) (linearize_instr instr k).
Proof.
- induction b; simpl; intros;
- try (generalize (cleanup_function_conservation
- _ _ (H1 _ (in_eq _ _)) I));
- inversion H0;
- try (elim H2; intro; [subst i|eauto with coqlib]);
- intros.
- (* getstack *)
- constructor. auto. eapply slot_is_bounded; eauto.
- simpl; auto with coqlib.
- eapply mreg_is_bounded; eauto.
- simpl; auto with coqlib.
- (* setstack *)
- constructor. auto. auto.
- eapply slot_is_bounded; eauto.
- simpl; auto with coqlib.
- (* move *)
- subst o; subst l. constructor. auto.
- eapply mreg_is_bounded; eauto.
- simpl; auto with coqlib.
- (* undef *)
- subst o; subst l. constructor.
- eapply mreg_is_bounded; eauto.
- simpl; auto with coqlib.
- (* other ops *)
- constructor; auto.
- eapply mreg_is_bounded; eauto.
- simpl; auto with coqlib.
- (* load *)
- constructor; auto.
- eapply mreg_is_bounded; eauto.
- simpl; auto with coqlib.
- (* store *)
- constructor; auto.
- (* call *)
- constructor; auto.
- eapply size_arguments_bound; eauto.
- (* alloc *)
- constructor.
- (* goto *)
- constructor.
- (* cond *)
- destruct (starts_with n k).
- elim H2; intro.
- subst i. constructor.
- rewrite H4. destruct c; reflexivity.
- elim H8; intro.
- subst i. constructor.
- eauto with coqlib.
- elim H2; intro.
- subst i. constructor. auto.
- elim H8; intro.
- subst i. constructor.
- eauto with coqlib.
- (* return *)
- constructor.
+ induction 1; simpl; intros.
+ apply wt_add_branch; auto.
+ apply wt_add_instr. constructor; auto. apply wt_add_branch; auto.
+ apply wt_add_instr. constructor; auto. apply wt_add_branch; auto.
+ apply wt_add_instr. constructor; auto. apply wt_add_branch; auto.
+ apply wt_add_instr. constructor; auto. apply wt_add_branch; auto.
+ apply wt_add_instr. constructor; auto. apply wt_add_branch; auto.
+ apply wt_add_instr. constructor; auto. auto.
+ apply wt_add_instr. constructor; auto. apply wt_add_branch; auto.
+ destruct (starts_with s1 k); apply wt_add_instr.
+ constructor; auto. rewrite H. destruct cond; auto.
+ apply wt_add_branch; auto.
+ constructor; auto. apply wt_add_branch; auto.
+ apply wt_add_instr. constructor; auto. auto.
Qed.
Lemma wt_linearize_body:
forall f,
- LTLtyping.wt_function f ->
- forall enum i,
- incl (linearize_body f enum) (linearize_function f).(fn_code) ->
- In i (linearize_body f enum) -> wt_instr (transf_function f) i.
-Proof.
- induction enum.
- simpl; intros; contradiction.
- intro i. simpl.
- caseEq (LTL.fn_code f)!a. intros b EQ INCL IN.
- elim IN; intro. subst i; constructor.
- apply wt_linearize_block with (linearize_body f enum) b.
- intros; apply IHenum.
- apply incl_tran with (linearize_block b (linearize_body f enum)).
- apply linearize_block_incl.
- eauto with coqlib.
- auto.
- eapply H; eauto.
- eauto with coqlib. auto.
+ (forall pc instr,
+ f.(LTL.fn_code)!pc = Some instr -> LTLtyping.wt_instr f instr) ->
+ forall enum,
+ wt_code f.(LTL.fn_sig) (linearize_body f enum).
+Proof.
+ induction enum; simpl.
+ red; simpl; intros; contradiction.
+ caseEq ((LTL.fn_code f)!a); intros.
+ apply wt_add_instr. constructor. apply wt_linearize_instr; eauto with coqlib.
auto.
-Qed.
+Qed.
Lemma wt_transf_function:
forall f,
LTLtyping.wt_function f ->
wt_function (transf_function f).
Proof.
- intros; red; intros.
- apply wt_linearize_body with (enumerate f); auto.
- simpl. apply incl_refl.
- apply cleanup_function_conservation_2; auto.
+ intros. inv H. constructor; auto.
+ simpl. apply wt_add_branch.
+ apply wt_linearize_body. auto.
Qed.
Lemma wt_transf_fundef:
@@ -342,7 +87,7 @@ Qed.
Lemma program_typing_preserved:
forall (p: LTL.program),
LTLtyping.wt_program p ->
- Lineartyping.wt_program (transf_program p).
+ LTLintyping.wt_program (transf_program p).
Proof.
intros; red; intros.
generalize (transform_program_function transf_fundef p i f H0).
diff --git a/backend/Lineartyping.v b/backend/Lineartyping.v
index cbe18311574c7785b938781ccc8c95affc64665c..baf522aad2989016d7f110c270162175043c7659 100644
--- a/backend/Lineartyping.v
+++ b/backend/Lineartyping.v
@@ -1,4 +1,4 @@
-(** Typing rules and computation of stack bounds for Linear. *)
+(** Typing rules for Linear. *)
Require Import Coqlib.
Require Import Maps.
@@ -9,218 +9,55 @@ Require Import Locations.
Require Import Linear.
Require Import Conventions.
-(** * Resource bounds for a function *)
-
-(** The [bounds] record capture how many local and outgoing stack slots
- and callee-save registers are used by a function. *)
-
-Record bounds : Set := mkbounds {
- bound_int_local: Z;
- bound_float_local: Z;
- bound_int_callee_save: Z;
- bound_float_callee_save: Z;
- bound_outgoing: Z
-}.
-
-(** The resource bounds for a function are computed by a linear scan
- of its instructions. *)
-
-Section BOUNDS.
-
-Variable f: function.
-
-Definition regs_of_instr (i: instruction) : list mreg :=
- match i with
- | Lgetstack s r => r :: nil
- | Lsetstack r s => r :: nil
- | Lop op args res => res :: args
- | Lload chunk addr args dst => dst :: args
- | Lstore chunk addr args src => src :: args
- | Lcall sig (inl fn) => fn :: nil
- | Lcall sig (inr _) => nil
- | Lalloc => nil
- | Llabel lbl => nil
- | Lgoto lbl => nil
- | Lcond cond args lbl => args
- | Lreturn => nil
- end.
-
-Definition slots_of_instr (i: instruction) : list slot :=
- match i with
- | Lgetstack s r => s :: nil
- | Lsetstack r s => s :: nil
- | _ => nil
- end.
-
-Definition max_over_list (A: Set) (valu: A -> Z) (l: list A) : Z :=
- List.fold_left (fun m l => Zmax m (valu l)) l 0.
-
-Definition max_over_instrs (valu: instruction -> Z) : Z :=
- max_over_list instruction valu f.(fn_code).
-
-Definition max_over_regs_of_instr (valu: mreg -> Z) (i: instruction) : Z :=
- max_over_list mreg valu (regs_of_instr i).
-
-Definition max_over_slots_of_instr (valu: slot -> Z) (i: instruction) : Z :=
- max_over_list slot valu (slots_of_instr i).
-
-Definition max_over_regs_of_funct (valu: mreg -> Z) : Z :=
- max_over_instrs (max_over_regs_of_instr valu).
-
-Definition max_over_slots_of_funct (valu: slot -> Z) : Z :=
- max_over_instrs (max_over_slots_of_instr valu).
-
-Definition int_callee_save (r: mreg) := 1 + index_int_callee_save r.
-
-Definition float_callee_save (r: mreg) := 1 + index_float_callee_save r.
-
-Definition int_local (s: slot) :=
- match s with Local ofs Tint => 1 + ofs | _ => 0 end.
-
-Definition float_local (s: slot) :=
- match s with Local ofs Tfloat => 1 + ofs | _ => 0 end.
-
-Definition outgoing_slot (s: slot) :=
- match s with Outgoing ofs ty => ofs + typesize ty | _ => 0 end.
-
-Definition outgoing_space (i: instruction) :=
- match i with Lcall sig _ => size_arguments sig | _ => 0 end.
-
-Definition function_bounds :=
- mkbounds
- (max_over_slots_of_funct int_local)
- (max_over_slots_of_funct float_local)
- (max_over_regs_of_funct int_callee_save)
- (max_over_regs_of_funct float_callee_save)
- (Zmax 6
- (Zmax (max_over_instrs outgoing_space)
- (max_over_slots_of_funct outgoing_slot))).
-
-(** We show that bounds computed by [function_bounds] are all positive
- or null, and moreover [bound_outgoing] is greater or equal to 6.
- These properties are used later to reason about the layout of
- the activation record. *)
-
-Lemma max_over_list_pos:
- forall (A: Set) (valu: A -> Z) (l: list A),
- max_over_list A valu l >= 0.
-Proof.
- intros until valu. unfold max_over_list.
- assert (forall l z, fold_left (fun x y => Zmax x (valu y)) l z >= z).
- induction l; simpl; intros.
- omega. apply Zge_trans with (Zmax z (valu a)).
- auto. apply Zle_ge. apply Zmax1. auto.
-Qed.
-
-Lemma max_over_slots_of_funct_pos:
- forall (valu: slot -> Z), max_over_slots_of_funct valu >= 0.
-Proof.
- intros. unfold max_over_slots_of_funct.
- unfold max_over_instrs. apply max_over_list_pos.
-Qed.
-
-Lemma max_over_regs_of_funct_pos:
- forall (valu: mreg -> Z), max_over_regs_of_funct valu >= 0.
-Proof.
- intros. unfold max_over_regs_of_funct.
- unfold max_over_instrs. apply max_over_list_pos.
-Qed.
-
-Lemma bound_int_local_pos:
- bound_int_local function_bounds >= 0.
-Proof.
- simpl. apply max_over_slots_of_funct_pos.
-Qed.
-
-Lemma bound_float_local_pos:
- bound_float_local function_bounds >= 0.
-Proof.
- simpl. apply max_over_slots_of_funct_pos.
-Qed.
-
-Lemma bound_int_callee_save_pos:
- bound_int_callee_save function_bounds >= 0.
-Proof.
- simpl. apply max_over_regs_of_funct_pos.
-Qed.
-
-Lemma bound_float_callee_save_pos:
- bound_float_callee_save function_bounds >= 0.
-Proof.
- simpl. apply max_over_regs_of_funct_pos.
-Qed.
-
-Lemma bound_outgoing_pos:
- bound_outgoing function_bounds >= 6.
-Proof.
- simpl. apply Zle_ge. apply Zmax_bound_l. omega.
-Qed.
-
-End BOUNDS.
-
-(** * Typing rules for Linear *)
-
-(** The typing rules for Linear are similar to those for LTL: we check
+(** The typing rules for Linear are similar to those for LTLin: we check
that instructions receive the right number of arguments,
and that the types of the argument and result registers agree
- with what the instruction expects. Moreover, we state that references
- to callee-save registers and to stack slots are within the bounds
- computed by [function_bounds]. This is true by construction of
- [function_bounds], and is proved in [Linearizetyping], but it
- is convenient to integrate this property within the typing judgement.
-*)
+ with what the instruction expects. Moreover, we also
+ enforces some correctness conditions on the offsets of stack slots
+ accessed through [Lgetstack] and [Lsetstack] Linear instructions. *)
Section WT_INSTR.
Variable funct: function.
-Let b := function_bounds funct.
-Definition mreg_bounded (r: mreg) :=
- match mreg_type r with
- | Tint => index_int_callee_save r < bound_int_callee_save b
- | Tfloat => index_float_callee_save r < bound_float_callee_save b
+Definition slot_valid (s: slot) :=
+ match s with
+ | Local ofs ty => 0 <= ofs
+ | Outgoing ofs ty => 14 <= ofs
+ | Incoming ofs ty => 14 <= ofs /\ ofs + typesize ty <= size_arguments funct.(fn_sig)
end.
-Definition slot_bounded (s: slot) :=
+Definition slot_writable (s: slot) :=
match s with
- | Local ofs Tint => 0 <= ofs < bound_int_local b
- | Local ofs Tfloat => 0 <= ofs < bound_float_local b
- | Outgoing ofs ty => 6 <= ofs /\ ofs + typesize ty <= bound_outgoing b
- | Incoming ofs ty => 6 <= ofs /\ ofs + typesize ty <= size_arguments funct.(fn_sig)
+ | Local ofs ty => True
+ | Outgoing ofs ty => True
+ | Incoming ofs ty => False
end.
Inductive wt_instr : instruction -> Prop :=
| wt_Lgetstack:
forall s r,
slot_type s = mreg_type r ->
- slot_bounded s -> mreg_bounded r ->
+ slot_valid s ->
wt_instr (Lgetstack s r)
| wt_Lsetstack:
forall s r,
- match s with Incoming _ _ => False | _ => True end ->
slot_type s = mreg_type r ->
- slot_bounded s ->
+ slot_valid s -> slot_writable s ->
wt_instr (Lsetstack r s)
| wt_Lopmove:
forall r1 r,
mreg_type r1 = mreg_type r ->
- mreg_bounded r ->
wt_instr (Lop Omove (r1 :: nil) r)
- | wt_Lopundef:
- forall r,
- mreg_bounded r ->
- wt_instr (Lop Oundef nil r)
| wt_Lop:
forall op args res,
- op <> Omove -> op <> Oundef ->
+ op <> Omove ->
(List.map mreg_type args, mreg_type res) = type_of_operation op ->
- mreg_bounded res ->
wt_instr (Lop op args res)
| wt_Lload:
forall chunk addr args dst,
List.map mreg_type args = type_of_addressing addr ->
mreg_type dst = type_of_chunk chunk ->
- mreg_bounded dst ->
wt_instr (Lload chunk addr args dst)
| wt_Lstore:
forall chunk addr args src,
@@ -229,9 +66,13 @@ Inductive wt_instr : instruction -> Prop :=
wt_instr (Lstore chunk addr args src)
| wt_Lcall:
forall sig ros,
- size_arguments sig <= bound_outgoing b ->
match ros with inl r => mreg_type r = Tint | _ => True end ->
wt_instr (Lcall sig ros)
+ | wt_Ltailcall:
+ forall sig ros,
+ tailcall_possible sig ->
+ match ros with inl r => r = IT3 | _ => True end ->
+ wt_instr (Ltailcall sig ros)
| wt_Lalloc:
wt_instr Lalloc
| wt_Llabel:
@@ -249,8 +90,11 @@ Inductive wt_instr : instruction -> Prop :=
End WT_INSTR.
+Definition wt_code (f: function) (c: code) : Prop :=
+ forall instr, In instr c -> wt_instr f instr.
+
Definition wt_function (f: function) : Prop :=
- forall instr, In instr f.(fn_code) -> wt_instr f instr.
+ wt_code f f.(fn_code).
Inductive wt_fundef: fundef -> Prop :=
| wt_fundef_external: forall ef,
diff --git a/backend/Locations.v b/backend/Locations.v
index c97855ea9ac5e6518d5c7e297ef034da0c273fe2..aaefc08c50fc743f0ecb68a84aaa473bcec474db 100644
--- a/backend/Locations.v
+++ b/backend/Locations.v
@@ -434,7 +434,7 @@ End Loc.
(** The [Locmap] module defines mappings from locations to values,
used as evaluation environments for the semantics of the [LTL]
- and [Linear] intermediate languages. *)
+ and [LTLin] intermediate languages. *)
Set Implicit Arguments.
diff --git a/backend/Mach.v b/backend/Mach.v
index f61620d11decd00a654cc665c42ca43f5e743317..05805ec5fee14264331aed5a504dfdf4d6548537 100644
--- a/backend/Mach.v
+++ b/backend/Mach.v
@@ -1,7 +1,8 @@
-(** The Mach intermediate language: abstract syntax and semantics.
+(** The Mach intermediate language: abstract syntax.
Mach is the last intermediate language before generation of assembly
- code.
+ code. This file defines the abstract syntax for Mach; two dynamic
+ semantics are given in modules [Machabstr] and [Machconcr].
*)
Require Import Coqlib.
@@ -14,7 +15,6 @@ Require Import Events.
Require Import Globalenvs.
Require Import Op.
Require Import Locations.
-Require Conventions.
(** * Abstract syntax *)
@@ -30,8 +30,8 @@ Require Conventions.
the caller.
These instructions implement a more concrete view of the activation
- record than the the [Bgetstack] and [Bsetstack] instructions of
- Linear: actual offsets are used instead of abstract stack slots; the
+ record than the the [Lgetstack] and [Lsetstack] instructions of
+ Linear: actual offsets are used instead of abstract stack slots, and the
distinction between the caller's frame and the callee's frame is
made explicit. *)
@@ -45,6 +45,7 @@ Inductive instruction: Set :=
| Mload: memory_chunk -> addressing -> list mreg -> mreg -> instruction
| Mstore: memory_chunk -> addressing -> list mreg -> mreg -> instruction
| Mcall: signature -> mreg + ident -> instruction
+ | Mtailcall: signature -> mreg + ident -> instruction
| Malloc: instruction
| Mlabel: label -> instruction
| Mgoto: label -> instruction
@@ -105,238 +106,25 @@ Fixpoint find_label (lbl: label) (c: code) {struct c} : option code :=
| i1 :: il => if is_label lbl i1 then Some il else find_label lbl il
end.
-(** The three stack-related Mach instructions are interpreted as
- memory accesses relative to the stack pointer. More precisely:
-- [Mgetstack ofs ty r] is a memory load at offset [ofs * 4] relative
- to the stack pointer.
-- [Msetstack r ofs ty] is a memory store at offset [ofs * 4] relative
- to the stack pointer.
-- [Mgetparam ofs ty r] is a memory load at offset [ofs * 4]
- relative to the pointer found at offset 0 from the stack pointer.
- The semantics maintain a linked structure of activation records,
- with the current record containing a pointer to the record of the
- caller function at offset 0. *)
-
-Definition chunk_of_type (ty: typ) :=
- match ty with Tint => Mint32 | Tfloat => Mfloat64 end.
-
-Definition load_stack (m: mem) (sp: val) (ty: typ) (ofs: int) :=
- Mem.loadv (chunk_of_type ty) m (Val.add sp (Vint ofs)).
-
-Definition store_stack (m: mem) (sp: val) (ty: typ) (ofs: int) (v: val) :=
- Mem.storev (chunk_of_type ty) m (Val.add sp (Vint ofs)) v.
-
-Definition align_16_top (lo hi: Z) :=
- Zmax 0 (((hi - lo + 15) / 16) * 16 + lo).
-
-Section RELSEM.
-
-Variable ge: genv.
+Lemma find_label_incl:
+ forall lbl c c', find_label lbl c = Some c' -> incl c' c.
+Proof.
+ induction c; simpl; intros. discriminate.
+ destruct (is_label lbl a). inv H. auto with coqlib. eauto with coqlib.
+Qed.
-Definition find_function (ros: mreg + ident) (rs: regset) : option fundef :=
+Definition find_function_ptr
+ (ge: genv) (ros: mreg + ident) (rs: regset) : option block :=
match ros with
- | inl r => Genv.find_funct ge (rs r)
- | inr symb =>
- match Genv.find_symbol ge symb with
- | None => None
- | Some b => Genv.find_funct_ptr ge b
+ | inl r =>
+ match rs r with
+ | Vptr b ofs => if Int.eq ofs Int.zero then Some b else None
+ | _ => None
end
+ | inr symb =>
+ Genv.find_symbol ge symb
end.
-(** Extract the values of the arguments of an external call. *)
-
-Inductive extcall_arg: regset -> mem -> val -> loc -> val -> Prop :=
- | extcall_arg_reg: forall rs m sp r,
- extcall_arg rs m sp (R r) (rs r)
- | extcall_arg_stack: forall rs m sp ofs ty v,
- load_stack m sp ty (Int.repr (4 * ofs)) = Some v ->
- extcall_arg rs m sp (S (Outgoing ofs ty)) v.
-
-Inductive extcall_args: regset -> mem -> val -> list loc -> list val -> Prop :=
- | extcall_args_nil: forall rs m sp,
- extcall_args rs m sp nil nil
- | extcall_args_cons: forall rs m sp l1 ll v1 vl,
- extcall_arg rs m sp l1 v1 -> extcall_args rs m sp ll vl ->
- extcall_args rs m sp (l1 :: ll) (v1 :: vl).
-
-Definition extcall_arguments
- (rs: regset) (m: mem) (sp: val) (sg: signature) (args: list val) : Prop :=
- extcall_args rs m sp (Conventions.loc_arguments sg) args.
-
-(** [exec_instr ge f sp c rs m c' rs' m'] reflects the execution of
- the first instruction in the current instruction sequence [c].
- [c'] is the current instruction sequence after this execution.
- [rs] and [rs'] map machine registers to values, respectively
- before and after instruction execution. [m] and [m'] are the
- memory states before and after. *)
-
-Inductive exec_instr:
- function -> val ->
- code -> regset -> mem -> trace ->
- code -> regset -> mem -> Prop :=
- | exec_Mlabel:
- forall f sp lbl c rs m,
- exec_instr f sp
- (Mlabel lbl :: c) rs m
- E0 c rs m
- | exec_Mgetstack:
- forall f sp ofs ty dst c rs m v,
- load_stack m sp ty ofs = Some v ->
- exec_instr f sp
- (Mgetstack ofs ty dst :: c) rs m
- E0 c (rs#dst <- v) m
- | exec_Msetstack:
- forall f sp src ofs ty c rs m m',
- store_stack m sp ty ofs (rs src) = Some m' ->
- exec_instr f sp
- (Msetstack src ofs ty :: c) rs m
- E0 c rs m'
- | exec_Mgetparam:
- forall f sp parent ofs ty dst c rs m v,
- load_stack m sp Tint (Int.repr 0) = Some parent ->
- load_stack m parent ty ofs = Some v ->
- exec_instr f sp
- (Mgetparam ofs ty dst :: c) rs m
- E0 c (rs#dst <- v) m
- | exec_Mop:
- forall f sp op args res c rs m v,
- eval_operation ge sp op rs##args = Some v ->
- exec_instr f sp
- (Mop op args res :: c) rs m
- E0 c (rs#res <- v) m
- | exec_Mload:
- forall f sp chunk addr args dst c rs m a v,
- eval_addressing ge sp addr rs##args = Some a ->
- Mem.loadv chunk m a = Some v ->
- exec_instr f sp
- (Mload chunk addr args dst :: c) rs m
- E0 c (rs#dst <- v) m
- | exec_Mstore:
- forall f sp chunk addr args src c rs m m' a,
- eval_addressing ge sp addr rs##args = Some a ->
- Mem.storev chunk m a (rs src) = Some m' ->
- exec_instr f sp
- (Mstore chunk addr args src :: c) rs m
- E0 c rs m'
- | exec_Mcall:
- forall f sp sig ros c rs m f' t rs' m',
- find_function ros rs = Some f' ->
- exec_function f' sp rs m t rs' m' ->
- exec_instr f sp
- (Mcall sig ros :: c) rs m
- t c rs' m'
- | exec_Malloc:
- forall f sp c rs m sz m' blk,
- rs (Conventions.loc_alloc_argument) = Vint sz ->
- Mem.alloc m 0 (Int.signed sz) = (m', blk) ->
- exec_instr f sp
- (Malloc :: c) rs m
- E0 c (rs#Conventions.loc_alloc_result <-
- (Vptr blk Int.zero)) m'
- | exec_Mgoto:
- forall f sp lbl c rs m c',
- find_label lbl f.(fn_code) = Some c' ->
- exec_instr f sp
- (Mgoto lbl :: c) rs m
- E0 c' rs m
- | exec_Mcond_true:
- forall f sp cond args lbl c rs m c',
- eval_condition cond rs##args = Some true ->
- find_label lbl f.(fn_code) = Some c' ->
- exec_instr f sp
- (Mcond cond args lbl :: c) rs m
- E0 c' rs m
- | exec_Mcond_false:
- forall f sp cond args lbl c rs m,
- eval_condition cond rs##args = Some false ->
- exec_instr f sp
- (Mcond cond args lbl :: c) rs m
- E0 c rs m
-
-with exec_instrs:
- function -> val ->
- code -> regset -> mem -> trace ->
- code -> regset -> mem -> Prop :=
- | exec_refl:
- forall f sp c rs m,
- exec_instrs f sp c rs m E0 c rs m
- | exec_one:
- forall f sp c rs m t c' rs' m',
- exec_instr f sp c rs m t c' rs' m' ->
- exec_instrs f sp c rs m t c' rs' m'
- | exec_trans:
- forall f sp c1 rs1 m1 t1 c2 rs2 m2 t2 c3 rs3 m3 t3,
- exec_instrs f sp c1 rs1 m1 t1 c2 rs2 m2 ->
- exec_instrs f sp c2 rs2 m2 t2 c3 rs3 m3 ->
- t3 = t1 ** t2 ->
- exec_instrs f sp c1 rs1 m1 t3 c3 rs3 m3
-
-(** In addition to reserving the word at offset 0 in the activation
- record for maintaining the linking of activation records,
- we need to reserve the word at offset 12 to store the return address
- into the caller. However, the return address (a pointer within
- the code of the caller) is not precisely known at this point:
- it will be determined only after the final translation to PowerPC
- assembly code. Therefore, we simply reserve that word in the strongest
- sense of the word ``reserve'': we make sure that whatever pointer
- is stored there at function entry keeps the same value until the
- final return instruction, and that the return value and final memory
- state are the same regardless of the return address.
- This is captured in the evaluation rule [exec_function]
- that quantifies universally over all possible values of the return
- address, and pass this value to [exec_function_body]. In other
- terms, the inference rule [exec_function] has an infinity of
- premises, one for each possible return address. Such infinitely
- branching inference rules are uncommon in operational semantics,
- but cause no difficulties in Coq. *)
-
-with exec_function_body:
- function -> val -> val ->
- regset -> mem -> trace -> regset -> mem -> Prop :=
- | exec_funct_body:
- forall f parent ra rs m t rs' m1 m2 m3 m4 stk c,
- Mem.alloc m (- f.(fn_framesize))
- (align_16_top (- f.(fn_framesize)) f.(fn_stacksize))
- = (m1, stk) ->
- let sp := Vptr stk (Int.repr (-f.(fn_framesize))) in
- store_stack m1 sp Tint (Int.repr 0) parent = Some m2 ->
- store_stack m2 sp Tint (Int.repr 12) ra = Some m3 ->
- exec_instrs f sp
- f.(fn_code) rs m3
- t (Mreturn :: c) rs' m4 ->
- load_stack m4 sp Tint (Int.repr 0) = Some parent ->
- load_stack m4 sp Tint (Int.repr 12) = Some ra ->
- exec_function_body f parent ra rs m t rs' (Mem.free m4 stk)
-
-with exec_function:
- fundef -> val -> regset -> mem -> trace -> regset -> mem -> Prop :=
- | exec_funct_internal:
- forall f parent rs m t rs' m',
- (forall ra,
- Val.has_type ra Tint ->
- exec_function_body f parent ra rs m t rs' m') ->
- exec_function (Internal f) parent rs m t rs' m'
- | exec_funct_external:
- forall ef parent args res rs1 rs2 m t,
- event_match ef args t res ->
- extcall_arguments rs1 m parent ef.(ef_sig) args ->
- rs2 = (rs1#(Conventions.loc_result ef.(ef_sig)) <- res) ->
- exec_function (External ef) parent rs1 m t rs2 m.
-
-Scheme exec_instr_ind4 := Minimality for exec_instr Sort Prop
- with exec_instrs_ind4 := Minimality for exec_instrs Sort Prop
- with exec_function_body_ind4 := Minimality for exec_function_body Sort Prop
- with exec_function_ind4 := Minimality for exec_function Sort Prop.
-
-End RELSEM.
-
-Definition exec_program (p: program) (t: trace) (r: val) : Prop :=
- let ge := Genv.globalenv p in
- let m0 := Genv.init_mem p in
- exists b, exists f, exists rs, exists m,
- Genv.find_symbol ge p.(prog_main) = Some b /\
- Genv.find_funct_ptr ge b = Some f /\
- exec_function ge f (Vptr Mem.nullptr Int.zero) (Regmap.init Vundef) m0
- t rs m /\
- rs R3 = r.
+Definition align_16_top (lo hi: Z) :=
+ Zmax 0 (((hi - lo + 15) / 16) * 16 + lo).
diff --git a/backend/Machabstr.v b/backend/Machabstr.v
index d83ffa51ff06bf42764116711239fc2ddb77640a..ad4e8e1a640f3743c89cf05c27084eab54b6093f 100644
--- a/backend/Machabstr.v
+++ b/backend/Machabstr.v
@@ -1,4 +1,4 @@
-(** Alternate semantics for the Mach intermediate language. *)
+(** The Mach intermediate language: abstract semantics. *)
Require Import Coqlib.
Require Import Maps.
@@ -9,37 +9,53 @@ Require Import Values.
Require Import Mem.
Require Import Events.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Op.
Require Import Locations.
Require Conventions.
Require Import Mach.
-(** This file defines an alternate semantics for the Mach intermediate
- language, which differ from the standard semantics given in file [Mach]
- as follows: the stack access instructions [Mgetstack], [Msetstack]
- and [Mgetparam] are interpreted not as memory accesses, but as
- accesses in a frame environment, not resident in memory. The evaluation
- relations take two such frame environments as parameters and results,
- one for the current function and one for its caller.
+(** This file defines the "abstract" semantics for the Mach
+ intermediate language, as opposed to the more concrete
+ semantics given in module [Machconcr].
+
+ The only difference with the concrete semantics is the interpretation
+ of the stack access instructions [Mgetstack], [Msetstack] and [Mgetparam].
+ In the concrete semantics, these are interpreted as memory accesses
+ relative to the stack pointer. In the abstract semantics, these
+ instructions are interpreted as accesses in a frame environment,
+ not resident in memory. The frame environment is an additional
+ component of the state.
Not having the frame data in memory facilitates the proof of
the [Stacking] pass, which shows that the generated code executes
- correctly with the alternate semantics. In file [Machabstr2mach],
- we show an implication from this alternate semantics to
- the standard semantics, thus establishing that the [Stacking] pass
- generates code that behaves correctly against the standard [Mach]
- semantics as well. *)
+ correctly with the abstract semantics.
+*)
(** * Structure of abstract stack frames *)
-(** A frame has the same structure as the contents of a memory block. *)
+(** An abstract stack frame comprises a low bound [fr_low] (the high bound
+ is implicitly 0) and a mapping from (type, offset) pairs to values. *)
+
+Record frame : Set := mkframe {
+ fr_low: Z;
+ fr_contents: typ -> Z -> val
+}.
-Definition frame := block_contents.
+Definition typ_eq: forall (ty1 ty2: typ), {ty1=ty2} + {ty1<>ty2}.
+Proof. decide equality. Defined.
-Definition empty_frame := empty_block 0 0.
+Definition update (ty: typ) (ofs: Z) (v: val) (f: frame) : frame :=
+ mkframe f.(fr_low)
+ (fun ty' ofs' =>
+ if zeq ofs ofs' then
+ if typ_eq ty ty' then v else Vundef
+ else
+ if zle (ofs' + AST.typesize ty') ofs then f.(fr_contents) ty' ofs'
+ else if zle (ofs + AST.typesize ty) ofs' then f.(fr_contents) ty' ofs'
+ else Vundef).
-Definition mem_type (ty: typ) :=
- match ty with Tint => Size32 | Tfloat => Size64 end.
+Definition empty_frame := mkframe 0 (fun ty ofs => Vundef).
(** [get_slot fr ty ofs v] holds if the frame [fr] contains value [v]
with type [ty] at word offset [ofs]. *)
@@ -47,46 +63,24 @@ Definition mem_type (ty: typ) :=
Inductive get_slot: frame -> typ -> Z -> val -> Prop :=
| get_slot_intro:
forall fr ty ofs v,
- 0 <= ofs ->
- fr.(low) + ofs + 4 * typesize ty <= 0 ->
- v = load_contents (mem_type ty) fr.(contents) (fr.(low) + ofs) ->
+ 24 <= ofs ->
+ fr.(fr_low) + ofs + AST.typesize ty <= 0 ->
+ v = fr.(fr_contents) ty (fr.(fr_low) + ofs) ->
get_slot fr ty ofs v.
-Remark size_mem_type:
- forall ty, size_mem (mem_type ty) = 4 * typesize ty.
-Proof.
- destruct ty; reflexivity.
-Qed.
-
-Remark set_slot_undef_outside:
- forall fr ty ofs v,
- fr.(high) = 0 ->
- 0 <= ofs ->
- fr.(low) + ofs + 4 * typesize ty <= 0 ->
- (forall x, x < fr.(low) \/ x >= fr.(high) -> fr.(contents) x = Undef) ->
- (forall x, x < fr.(low) \/ x >= fr.(high) ->
- store_contents (mem_type ty) fr.(contents) (fr.(low) + ofs) v x = Undef).
-Proof.
- intros. apply store_contents_undef_outside with fr.(low) fr.(high).
- rewrite <- size_mem_type in H1. omega. assumption. assumption.
-Qed.
-
(** [set_slot fr ty ofs v fr'] holds if frame [fr'] is obtained from
frame [fr] by storing value [v] with type [ty] at word offset [ofs]. *)
Inductive set_slot: frame -> typ -> Z -> val -> frame -> Prop :=
| set_slot_intro:
- forall fr ty ofs v
- (A: fr.(high) = 0)
- (B: 0 <= ofs)
- (C: fr.(low) + ofs + 4 * typesize ty <= 0),
- set_slot fr ty ofs v
- (mkblock fr.(low) fr.(high)
- (store_contents (mem_type ty) fr.(contents) (fr.(low) + ofs) v)
- (set_slot_undef_outside fr ty ofs v A B C fr.(undef_outside))).
+ forall fr ty ofs v fr',
+ 24 <= ofs ->
+ fr.(fr_low) + ofs + AST.typesize ty <= 0 ->
+ fr' = update ty (fr.(fr_low) + ofs) v fr ->
+ set_slot fr ty ofs v fr'.
Definition init_frame (f: function) :=
- empty_block (- f.(fn_framesize)) 0.
+ mkframe (- f.(fn_framesize)) (fun ty ofs => Vundef).
(** Extract the values of the arguments of an external call. *)
@@ -108,320 +102,172 @@ Definition extcall_arguments
(rs: regset) (fr: frame) (sg: signature) (args: list val) : Prop :=
extcall_args rs fr (Conventions.loc_arguments sg) args.
+(** The components of an execution state are:
+
+- [State cs f sp c rs fr m]: [f] is the function currently executing.
+ [sp] is the stack pointer. [c] is the list of instructions that
+ remain to be executed. [rs] assigns values to registers.
+ [fr] is the current frame, as described above. [m] is the memory state.
+- [Callstate cs f rs m]: [f] is the function definition being called.
+ [rs] is the current values of registers,
+ and [m] the current memory state.
+- [Returnstate cs rs m]: [rs] is the current values of registers,
+ and [m] the current memory state.
+
+[cs] is a list of stack frames [Stackframe f sp c fr],
+where [f] is the block reference for the calling function,
+[c] the code within this function that follows the call instruction,
+[sp] its stack pointer, and [fr] its private frame. *)
+
+Inductive stackframe: Set :=
+ | Stackframe:
+ forall (f: function) (sp: val) (c: code) (fr: frame),
+ stackframe.
+
+Inductive state: Set :=
+ | State:
+ forall (stack: list stackframe) (f: function) (sp: val)
+ (c: code) (rs: regset) (fr: frame) (m: mem),
+ state
+ | Callstate:
+ forall (stack: list stackframe) (f: fundef) (rs: regset) (m: mem),
+ state
+ | Returnstate:
+ forall (stack: list stackframe) (rs: regset) (m: mem),
+ state.
+
+(** [parent_frame s] returns the frame of the calling function.
+ It is used to access function parameters that are passed on the stack
+ (the [Mgetparent] instruction). *)
+
+Definition parent_frame (s: list stackframe) : frame :=
+ match s with
+ | nil => empty_frame
+ | Stackframe f sp c fr :: s => fr
+ end.
+
Section RELSEM.
Variable ge: genv.
-(** Execution of one instruction has the form
- [exec_instr ge f sp parent c rs fr m c' rs' fr' m'],
- where [parent] is the caller's frame (read-only)
- and [fr], [fr'] are the current frame, before and after execution
- of one instruction. The other parameters are as in the Mach semantics. *)
+Definition find_function (ros: mreg + ident) (rs: regset) : option fundef :=
+ match ros with
+ | inl r => Genv.find_funct ge (rs r)
+ | inr symb =>
+ match Genv.find_symbol ge symb with
+ | None => None
+ | Some b => Genv.find_funct_ptr ge b
+ end
+ end.
-Inductive exec_instr:
- function -> val -> frame ->
- code -> regset -> frame -> mem -> trace ->
- code -> regset -> frame -> mem -> Prop :=
+Inductive step: state -> trace -> state -> Prop :=
| exec_Mlabel:
- forall f sp parent lbl c rs fr m,
- exec_instr f sp parent
- (Mlabel lbl :: c) rs fr m
- E0 c rs fr m
+ forall s f sp lbl c rs fr m,
+ step (State s f sp (Mlabel lbl :: c) rs fr m)
+ E0 (State s f sp c rs fr m)
| exec_Mgetstack:
- forall f sp parent ofs ty dst c rs fr m v,
+ forall s f sp ofs ty dst c rs fr m v,
get_slot fr ty (Int.signed ofs) v ->
- exec_instr f sp parent
- (Mgetstack ofs ty dst :: c) rs fr m
- E0 c (rs#dst <- v) fr m
+ step (State s f sp (Mgetstack ofs ty dst :: c) rs fr m)
+ E0 (State s f sp c (rs#dst <- v) fr m)
| exec_Msetstack:
- forall f sp parent src ofs ty c rs fr m fr',
+ forall s f sp src ofs ty c rs fr m fr',
set_slot fr ty (Int.signed ofs) (rs src) fr' ->
- exec_instr f sp parent
- (Msetstack src ofs ty :: c) rs fr m
- E0 c rs fr' m
+ step (State s f sp (Msetstack src ofs ty :: c) rs fr m)
+ E0 (State s f sp c rs fr' m)
| exec_Mgetparam:
- forall f sp parent ofs ty dst c rs fr m v,
- get_slot parent ty (Int.signed ofs) v ->
- exec_instr f sp parent
- (Mgetparam ofs ty dst :: c) rs fr m
- E0 c (rs#dst <- v) fr m
+ forall s f sp ofs ty dst c rs fr m v,
+ get_slot (parent_frame s) ty (Int.signed ofs) v ->
+ step (State s f sp (Mgetparam ofs ty dst :: c) rs fr m)
+ E0 (State s f sp c (rs#dst <- v) fr m)
| exec_Mop:
- forall f sp parent op args res c rs fr m v,
- eval_operation ge sp op rs##args = Some v ->
- exec_instr f sp parent
- (Mop op args res :: c) rs fr m
- E0 c (rs#res <- v) fr m
+ forall s f sp op args res c rs fr m v,
+ eval_operation ge sp op rs##args m = Some v ->
+ step (State s f sp (Mop op args res :: c) rs fr m)
+ E0 (State s f sp c (rs#res <- v) fr m)
| exec_Mload:
- forall f sp parent chunk addr args dst c rs fr m a v,
+ forall s f sp chunk addr args dst c rs fr m a v,
eval_addressing ge sp addr rs##args = Some a ->
Mem.loadv chunk m a = Some v ->
- exec_instr f sp parent
- (Mload chunk addr args dst :: c) rs fr m
- E0 c (rs#dst <- v) fr m
+ step (State s f sp (Mload chunk addr args dst :: c) rs fr m)
+ E0 (State s f sp c (rs#dst <- v) fr m)
| exec_Mstore:
- forall f sp parent chunk addr args src c rs fr m m' a,
+ forall s f sp chunk addr args src c rs fr m m' a,
eval_addressing ge sp addr rs##args = Some a ->
Mem.storev chunk m a (rs src) = Some m' ->
- exec_instr f sp parent
- (Mstore chunk addr args src :: c) rs fr m
- E0 c rs fr m'
+ step (State s f sp (Mstore chunk addr args src :: c) rs fr m)
+ E0 (State s f sp c rs fr m')
| exec_Mcall:
- forall f sp parent sig ros c rs fr m t f' rs' m',
- find_function ge ros rs = Some f' ->
- exec_function f' fr rs m t rs' m' ->
- exec_instr f sp parent
- (Mcall sig ros :: c) rs fr m
- t c rs' fr m'
+ forall s f sp sig ros c rs fr m f',
+ find_function ros rs = Some f' ->
+ step (State s f sp (Mcall sig ros :: c) rs fr m)
+ E0 (Callstate (Stackframe f sp c fr :: s) f' rs m)
+ | exec_Mtailcall:
+ forall s f stk soff sig ros c rs fr m f',
+ find_function ros rs = Some f' ->
+ step (State s f (Vptr stk soff) (Mtailcall sig ros :: c) rs fr m)
+ E0 (Callstate s f' rs (Mem.free m stk))
+
| exec_Malloc:
- forall f sp parent c rs fr m sz m' blk,
+ forall s f sp c rs fr m sz m' blk,
rs (Conventions.loc_alloc_argument) = Vint sz ->
Mem.alloc m 0 (Int.signed sz) = (m', blk) ->
- exec_instr f sp parent
- (Malloc :: c) rs fr m
- E0 c (rs#Conventions.loc_alloc_result <-
- (Vptr blk Int.zero)) fr m'
+ step (State s f sp (Malloc :: c) rs fr m)
+ E0 (State s f sp c
+ (rs#Conventions.loc_alloc_result <- (Vptr blk Int.zero))
+ fr m')
| exec_Mgoto:
- forall f sp parent lbl c rs fr m c',
+ forall s f sp lbl c rs fr m c',
find_label lbl f.(fn_code) = Some c' ->
- exec_instr f sp parent
- (Mgoto lbl :: c) rs fr m
- E0 c' rs fr m
+ step (State s f sp (Mgoto lbl :: c) rs fr m)
+ E0 (State s f sp c' rs fr m)
| exec_Mcond_true:
- forall f sp parent cond args lbl c rs fr m c',
- eval_condition cond rs##args = Some true ->
+ forall s f sp cond args lbl c rs fr m c',
+ eval_condition cond rs##args m = Some true ->
find_label lbl f.(fn_code) = Some c' ->
- exec_instr f sp parent
- (Mcond cond args lbl :: c) rs fr m
- E0 c' rs fr m
+ step (State s f sp (Mcond cond args lbl :: c) rs fr m)
+ E0 (State s f sp c' rs fr m)
| exec_Mcond_false:
- forall f sp parent cond args lbl c rs fr m,
- eval_condition cond rs##args = Some false ->
- exec_instr f sp parent
- (Mcond cond args lbl :: c) rs fr m
- E0 c rs fr m
-
-with exec_instrs:
- function -> val -> frame ->
- code -> regset -> frame -> mem -> trace ->
- code -> regset -> frame -> mem -> Prop :=
- | exec_refl:
- forall f sp parent c rs fr m,
- exec_instrs f sp parent c rs fr m E0 c rs fr m
- | exec_one:
- forall f sp parent c rs fr m t c' rs' fr' m',
- exec_instr f sp parent c rs fr m t c' rs' fr' m' ->
- exec_instrs f sp parent c rs fr m t c' rs' fr' m'
- | exec_trans:
- forall f sp parent c1 rs1 fr1 m1 t1 c2 rs2 fr2 m2 t2 c3 rs3 fr3 m3 t3,
- exec_instrs f sp parent c1 rs1 fr1 m1 t1 c2 rs2 fr2 m2 ->
- exec_instrs f sp parent c2 rs2 fr2 m2 t2 c3 rs3 fr3 m3 ->
- t3 = t1 ** t2 ->
- exec_instrs f sp parent c1 rs1 fr1 m1 t3 c3 rs3 fr3 m3
-
-with exec_function_body:
- function -> frame -> val -> val ->
- regset -> mem -> trace -> regset -> mem -> Prop :=
- | exec_funct_body:
- forall f parent link ra rs m t rs' m1 m2 stk fr1 fr2 fr3 c,
- Mem.alloc m 0 f.(fn_stacksize) = (m1, stk) ->
- set_slot (init_frame f) Tint 0 link fr1 ->
- set_slot fr1 Tint 12 ra fr2 ->
- exec_instrs f (Vptr stk (Int.repr (-f.(fn_framesize)))) parent
- f.(fn_code) rs fr2 m1
- t (Mreturn :: c) rs' fr3 m2 ->
- exec_function_body f parent link ra rs m t rs' (Mem.free m2 stk)
-
-with exec_function:
- fundef -> frame -> regset -> mem -> trace -> regset -> mem -> Prop :=
- | exec_funct_internal:
- forall f parent rs m t rs' m',
- (forall link ra,
- Val.has_type link Tint ->
- Val.has_type ra Tint ->
- exec_function_body f parent link ra rs m t rs' m') ->
- exec_function (Internal f) parent rs m t rs' m'
- | exec_funct_external:
- forall ef parent args res rs1 rs2 m t,
+ forall s f sp cond args lbl c rs fr m,
+ eval_condition cond rs##args m = Some false ->
+ step (State s f sp (Mcond cond args lbl :: c) rs fr m)
+ E0 (State s f sp c rs fr m)
+ | exec_Mreturn:
+ forall s f stk soff c rs fr m,
+ step (State s f (Vptr stk soff) (Mreturn :: c) rs fr m)
+ E0 (Returnstate s rs (Mem.free m stk))
+ | exec_function_internal:
+ forall s f rs m m' stk,
+ Mem.alloc m 0 f.(fn_stacksize) = (m', stk) ->
+ step (Callstate s (Internal f) rs m)
+ E0 (State s f (Vptr stk (Int.repr (-f.(fn_framesize))))
+ f.(fn_code) rs (init_frame f) m')
+ | exec_function_external:
+ forall s ef args res rs1 rs2 m t,
event_match ef args t res ->
- extcall_arguments rs1 parent ef.(ef_sig) args ->
+ extcall_arguments rs1 (parent_frame s) ef.(ef_sig) args ->
rs2 = (rs1#(Conventions.loc_result ef.(ef_sig)) <- res) ->
- exec_function (External ef) parent rs1 m t rs2 m.
-
-Scheme exec_instr_ind4 := Minimality for exec_instr Sort Prop
- with exec_instrs_ind4 := Minimality for exec_instrs Sort Prop
- with exec_function_body_ind4 := Minimality for exec_function_body Sort Prop
- with exec_function_ind4 := Minimality for exec_function Sort Prop.
-
-(** Ugly mutual induction principle over evaluation derivations.
- Coq is not able to generate it directly, even though it is
- an immediate consequence of the 4 induction principles generated
- by the [Scheme] command above. *)
-
-Lemma exec_mutual_induction:
- forall
- (P
- P0 : function ->
- val ->
- frame ->
- code ->
- regset ->
- frame ->
- mem -> trace -> code -> regset -> frame -> mem -> Prop)
- (P1 : function ->
- frame ->
- val -> val -> regset -> mem -> trace -> regset -> mem -> Prop)
- (P2 : fundef ->
- frame -> regset -> mem -> trace -> regset -> mem -> Prop),
- (forall (f : function) (sp : val) (parent : frame) (lbl : label)
- (c : list instruction) (rs : regset) (fr : frame) (m : mem),
- P f sp parent (Mlabel lbl :: c) rs fr m E0 c rs fr m) ->
- (forall (f0 : function) (sp : val) (parent : frame) (ofs : int)
- (ty : typ) (dst : mreg) (c : list instruction) (rs : regset)
- (fr : frame) (m : mem) (v : val),
- get_slot fr ty (Int.signed ofs) v ->
- P f0 sp parent (Mgetstack ofs ty dst :: c) rs fr m E0 c rs # dst <- v
- fr m) ->
- (forall (f1 : function) (sp : val) (parent : frame) (src : mreg)
- (ofs : int) (ty : typ) (c : list instruction) (rs : mreg -> val)
- (fr : frame) (m : mem) (fr' : frame),
- set_slot fr ty (Int.signed ofs) (rs src) fr' ->
- P f1 sp parent (Msetstack src ofs ty :: c) rs fr m E0 c rs fr' m) ->
- (forall (f2 : function) (sp : val) (parent : frame) (ofs : int)
- (ty : typ) (dst : mreg) (c : list instruction) (rs : regset)
- (fr : frame) (m : mem) (v : val),
- get_slot parent ty (Int.signed ofs) v ->
- P f2 sp parent (Mgetparam ofs ty dst :: c) rs fr m E0 c rs # dst <- v
- fr m) ->
- (forall (f3 : function) (sp : val) (parent : frame) (op : operation)
- (args : list mreg) (res : mreg) (c : list instruction)
- (rs : mreg -> val) (fr : frame) (m : mem) (v : val),
- eval_operation ge sp op rs ## args = Some v ->
- P f3 sp parent (Mop op args res :: c) rs fr m E0 c rs # res <- v fr m) ->
- (forall (f4 : function) (sp : val) (parent : frame)
- (chunk : memory_chunk) (addr : addressing) (args : list mreg)
- (dst : mreg) (c : list instruction) (rs : mreg -> val) (fr : frame)
- (m : mem) (a v : val),
- eval_addressing ge sp addr rs ## args = Some a ->
- loadv chunk m a = Some v ->
- P f4 sp parent (Mload chunk addr args dst :: c) rs fr m E0 c
- rs # dst <- v fr m) ->
- (forall (f5 : function) (sp : val) (parent : frame)
- (chunk : memory_chunk) (addr : addressing) (args : list mreg)
- (src : mreg) (c : list instruction) (rs : mreg -> val) (fr : frame)
- (m m' : mem) (a : val),
- eval_addressing ge sp addr rs ## args = Some a ->
- storev chunk m a (rs src) = Some m' ->
- P f5 sp parent (Mstore chunk addr args src :: c) rs fr m E0 c rs fr
- m') ->
- (forall (f6 : function) (sp : val) (parent : frame) (sig : signature)
- (ros : mreg + ident) (c : list instruction) (rs : regset)
- (fr : frame) (m : mem) (t : trace) (f' : fundef) (rs' : regset)
- (m' : mem),
- find_function ge ros rs = Some f' ->
- exec_function f' fr rs m t rs' m' ->
- P2 f' fr rs m t rs' m' ->
- P f6 sp parent (Mcall sig ros :: c) rs fr m t c rs' fr m') ->
- (forall (f7 : function) (sp : val) (parent : frame)
- (c : list instruction) (rs : mreg -> val) (fr : frame) (m : mem)
- (sz : int) (m' : mem) (blk : block),
- rs Conventions.loc_alloc_argument = Vint sz ->
- alloc m 0 (Int.signed sz) = (m', blk) ->
- P f7 sp parent (Malloc :: c) rs fr m E0 c
- rs # Conventions.loc_alloc_result <- (Vptr blk Int.zero) fr m') ->
- (forall (f7 : function) (sp : val) (parent : frame) (lbl : label)
- (c : list instruction) (rs : regset) (fr : frame) (m : mem)
- (c' : code),
- find_label lbl (fn_code f7) = Some c' ->
- P f7 sp parent (Mgoto lbl :: c) rs fr m E0 c' rs fr m) ->
- (forall (f8 : function) (sp : val) (parent : frame) (cond : condition)
- (args : list mreg) (lbl : label) (c : list instruction)
- (rs : mreg -> val) (fr : frame) (m : mem) (c' : code),
- eval_condition cond rs ## args = Some true ->
- find_label lbl (fn_code f8) = Some c' ->
- P f8 sp parent (Mcond cond args lbl :: c) rs fr m E0 c' rs fr m) ->
- (forall (f9 : function) (sp : val) (parent : frame) (cond : condition)
- (args : list mreg) (lbl : label) (c : list instruction)
- (rs : mreg -> val) (fr : frame) (m : mem),
- eval_condition cond rs ## args = Some false ->
- P f9 sp parent (Mcond cond args lbl :: c) rs fr m E0 c rs fr m) ->
- (forall (f10 : function) (sp : val) (parent : frame) (c : code)
- (rs : regset) (fr : frame) (m : mem),
- P0 f10 sp parent c rs fr m E0 c rs fr m) ->
- (forall (f11 : function) (sp : val) (parent : frame) (c : code)
- (rs : regset) (fr : frame) (m : mem) (t : trace) (c' : code)
- (rs' : regset) (fr' : frame) (m' : mem),
- exec_instr f11 sp parent c rs fr m t c' rs' fr' m' ->
- P f11 sp parent c rs fr m t c' rs' fr' m' ->
- P0 f11 sp parent c rs fr m t c' rs' fr' m') ->
- (forall (f12 : function) (sp : val) (parent : frame) (c1 : code)
- (rs1 : regset) (fr1 : frame) (m1 : mem) (t1 : trace) (c2 : code)
- (rs2 : regset) (fr2 : frame) (m2 : mem) (t2 : trace) (c3 : code)
- (rs3 : regset) (fr3 : frame) (m3 : mem) (t3 : trace),
- exec_instrs f12 sp parent c1 rs1 fr1 m1 t1 c2 rs2 fr2 m2 ->
- P0 f12 sp parent c1 rs1 fr1 m1 t1 c2 rs2 fr2 m2 ->
- exec_instrs f12 sp parent c2 rs2 fr2 m2 t2 c3 rs3 fr3 m3 ->
- P0 f12 sp parent c2 rs2 fr2 m2 t2 c3 rs3 fr3 m3 ->
- t3 = t1 ** t2 -> P0 f12 sp parent c1 rs1 fr1 m1 t3 c3 rs3 fr3 m3) ->
- (forall (f13 : function) (parent : frame) (link ra : val)
- (rs : regset) (m : mem) (t : trace) (rs' : regset) (m1 m2 : mem)
- (stk : block) (fr1 fr2 fr3 : frame) (c : list instruction),
- alloc m 0 (fn_stacksize f13) = (m1, stk) ->
- set_slot (init_frame f13) Tint 0 link fr1 ->
- set_slot fr1 Tint 12 ra fr2 ->
- exec_instrs f13 (Vptr stk (Int.repr (- fn_framesize f13))) parent
- (fn_code f13) rs fr2 m1 t (Mreturn :: c) rs' fr3 m2 ->
- P0 f13 (Vptr stk (Int.repr (- fn_framesize f13))) parent
- (fn_code f13) rs fr2 m1 t (Mreturn :: c) rs' fr3 m2 ->
- P1 f13 parent link ra rs m t rs' (free m2 stk)) ->
- (forall (f14 : function) (parent : frame) (rs : regset) (m : mem)
- (t : trace) (rs' : regset) (m' : mem),
- (forall link ra : val,
- Val.has_type link Tint ->
- Val.has_type ra Tint ->
- exec_function_body f14 parent link ra rs m t rs' m') ->
- (forall link ra : val,
- Val.has_type link Tint ->
- Val.has_type ra Tint -> P1 f14 parent link ra rs m t rs' m') ->
- P2 (Internal f14) parent rs m t rs' m') ->
- (forall (ef : external_function) (parent : frame) (args : list val)
- (res : val) (rs1 : mreg -> val) (rs2 : RegEq.t -> val) (m : mem)
- (t0 : trace),
- event_match ef args t0 res ->
- extcall_arguments rs1 parent ef.(ef_sig) args ->
- rs2 = rs1 # (Conventions.loc_result (ef_sig ef)) <- res ->
- P2 (External ef) parent rs1 m t0 rs2 m) ->
- (forall (f16 : function) (v : val) (f17 : frame) (c : code)
- (r : regset) (f18 : frame) (m : mem) (t : trace) (c0 : code)
- (r0 : regset) (f19 : frame) (m0 : mem),
- exec_instr f16 v f17 c r f18 m t c0 r0 f19 m0 ->
- P f16 v f17 c r f18 m t c0 r0 f19 m0)
- /\ (forall (f16 : function) (v : val) (f17 : frame) (c : code)
- (r : regset) (f18 : frame) (m : mem) (t : trace) (c0 : code)
- (r0 : regset) (f19 : frame) (m0 : mem),
- exec_instrs f16 v f17 c r f18 m t c0 r0 f19 m0 ->
- P0 f16 v f17 c r f18 m t c0 r0 f19 m0)
- /\ (forall (f16 : function) (f17 : frame) (v v0 : val) (r : regset)
- (m : mem) (t : trace) (r0 : regset) (m0 : mem),
- exec_function_body f16 f17 v v0 r m t r0 m0 ->
- P1 f16 f17 v v0 r m t r0 m0)
- /\ (forall (f16 : fundef) (f17 : frame) (r : regset) (m : mem) (t : trace)
- (r0 : regset) (m0 : mem),
- exec_function f16 f17 r m t r0 m0 -> P2 f16 f17 r m t r0 m0).
-Proof.
- intros. split. apply (exec_instr_ind4 P P0 P1 P2); assumption.
- split. apply (exec_instrs_ind4 P P0 P1 P2); assumption.
- split. apply (exec_function_body_ind4 P P0 P1 P2); assumption.
- apply (exec_function_ind4 P P0 P1 P2); assumption.
-Qed.
+ step (Callstate s (External ef) rs1 m)
+ t (Returnstate s rs2 m)
+ | exec_return:
+ forall f sp c fr s rs m,
+ step (Returnstate (Stackframe f sp c fr :: s) rs m)
+ E0 (State s f sp c rs fr m).
End RELSEM.
-Definition exec_program (p: program) (t: trace) (r: val) : Prop :=
- let ge := Genv.globalenv p in
- let m0 := Genv.init_mem p in
- exists b, exists f, exists rs, exists m,
- Genv.find_symbol ge p.(prog_main) = Some b /\
- Genv.find_funct_ptr ge b = Some f /\
- exec_function ge f empty_frame (Regmap.init Vundef) m0 t rs m /\
- rs R3 = r.
+Inductive initial_state (p: program): state -> Prop :=
+ | initial_state_intro: forall b f,
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ Genv.find_symbol ge p.(prog_main) = Some b ->
+ Genv.find_funct_ptr ge b = Some f ->
+ initial_state p (Callstate nil f (Regmap.init Vundef) m0).
+
+Inductive final_state: state -> int -> Prop :=
+ | final_state_intro: forall rs m r,
+ rs R3 = Vint r ->
+ final_state (Returnstate nil rs m) r.
+Definition exec_program (p: program) (beh: program_behavior) : Prop :=
+ program_behaves step (initial_state p) final_state (Genv.globalenv p) beh.
diff --git a/backend/Machabstr2concr.v b/backend/Machabstr2concr.v
new file mode 100644
index 0000000000000000000000000000000000000000..5349fb500504cba64fd15f64a8cdba7589621cef
--- /dev/null
+++ b/backend/Machabstr2concr.v
@@ -0,0 +1,947 @@
+(** Simulation between the two semantics for the Mach language. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Integers.
+Require Import Values.
+Require Import Mem.
+Require Import Events.
+Require Import Globalenvs.
+Require Import Smallstep.
+Require Import Op.
+Require Import Locations.
+Require Import Mach.
+Require Import Machtyping.
+Require Import Machabstr.
+Require Import Machconcr.
+Require Import Stackingproof.
+Require Import PPCgenretaddr.
+
+(** Two semantics were defined for the Mach intermediate language:
+- The concrete semantics (file [Mach]), where the whole activation
+ record resides in memory and the [Mgetstack], [Msetstack] and
+ [Mgetparent] are interpreted as [sp]-relative memory accesses.
+- The abstract semantics (file [Machabstr]), where the activation
+ record is split in two parts: the Cminor stack data, resident in
+ memory, and the frame information, residing not in memory but
+ in additional evaluation environments.
+
+ In this file, we show a simulation result between these
+ semantics: if a program executes with some behaviour [beh] in the
+ abstract semantics, it also executes with the same behaviour in
+ the concrete semantics. This result bridges the correctness proof
+ in file [Stackingproof] (which uses the abstract Mach semantics
+ as output) and that in file [PPCgenproof] (which uses the concrete
+ Mach semantics as input).
+*)
+
+Remark align_16_top_ge:
+ forall lo hi,
+ hi <= align_16_top lo hi.
+Proof.
+ intros. unfold align_16_top. apply Zmax_bound_r.
+ assert (forall x, x <= (x + 15) / 16 * 16).
+ intro. assert (16 > 0). omega.
+ generalize (Z_div_mod_eq (x + 15) 16 H). intro.
+ replace ((x + 15) / 16 * 16) with ((x + 15) - (x + 15) mod 16).
+ generalize (Z_mod_lt (x + 15) 16 H). omega.
+ rewrite Zmult_comm. omega.
+ generalize (H (hi - lo)). omega.
+Qed.
+
+Remark align_16_top_pos:
+ forall lo hi,
+ 0 <= align_16_top lo hi.
+Proof.
+ intros. unfold align_16_top. apply Zmax_bound_l. omega.
+Qed.
+
+Remark size_type_chunk:
+ forall ty, size_chunk (chunk_of_type ty) = AST.typesize ty.
+Proof.
+ destruct ty; reflexivity.
+Qed.
+
+(** * Agreement between frames and memory-resident activation records *)
+
+(** ** Agreement for one frame *)
+
+(** The core idea of the simulation proof is that for all active
+ functions, the memory-allocated activation record, in the concrete
+ semantics, contains the same data as the Cminor stack block
+ (at positive offsets) and the frame of the function (at negative
+ offsets) in the abstract semantics.
+
+ This intuition (activation record = Cminor stack data + frame)
+ is formalized by the following predicate [frame_match fr sp base mm ms].
+ [fr] is a frame and [mm] the current memory state in the abstract
+ semantics. [ms] is the current memory state in the concrete semantics.
+ The stack pointer is [Vptr sp base] in both semantics. *)
+
+Inductive frame_match (fr: frame) (sp: block) (base: int)
+ (mm ms: mem) : Prop :=
+ frame_match_intro:
+ valid_block ms sp ->
+ low_bound mm sp = 0 ->
+ low_bound ms sp = fr.(fr_low) ->
+ high_bound ms sp >= 0 ->
+ fr.(fr_low) <= -24 ->
+ Int.min_signed <= fr.(fr_low) ->
+ base = Int.repr fr.(fr_low) ->
+ (forall ty ofs,
+ fr.(fr_low) + 24 <= ofs -> ofs + AST.typesize ty <= 0 ->
+ load (chunk_of_type ty) ms sp ofs = Some(fr.(fr_contents) ty ofs)) ->
+ frame_match fr sp base mm ms.
+
+(** The following two innocuous-looking lemmas are the key results
+ showing that [sp]-relative memory accesses in the concrete
+ semantics behave like the direct frame accesses in the abstract
+ semantics. First, a value [v] that has type [ty] is preserved
+ when stored in memory with chunk [chunk_of_type ty], then read
+ back with the same chunk. The typing hypothesis is crucial here:
+ for instance, a float value reads back as [Vundef] when stored
+ and load with chunk [Mint32]. *)
+
+Lemma load_result_ty:
+ forall v ty,
+ Val.has_type v ty -> Val.load_result (chunk_of_type ty) v = v.
+Proof.
+ destruct v; destruct ty; simpl; contradiction || reflexivity.
+Qed.
+
+(** Second, computations of [sp]-relative offsets using machine
+ arithmetic (as done in the concrete semantics) never overflows
+ and behaves identically to the offset computations using exact
+ arithmetic (as done in the abstract semantics). *)
+
+Lemma int_add_no_overflow:
+ forall x y,
+ Int.min_signed <= Int.signed x + Int.signed y <= Int.max_signed ->
+ Int.signed (Int.add x y) = Int.signed x + Int.signed y.
+Proof.
+ intros. rewrite Int.add_signed. rewrite Int.signed_repr. auto. auto.
+Qed.
+
+(** Given matching frames and activation records, loading from the
+ activation record (in the concrete semantics) behaves identically
+ to reading the corresponding slot from the frame
+ (in the abstract semantics). *)
+
+Lemma frame_match_get_slot:
+ forall fr sp base mm ms ty ofs v,
+ frame_match fr sp base mm ms ->
+ get_slot fr ty (Int.signed ofs) v ->
+ load_stack ms (Vptr sp base) ty ofs = Some v.
+Proof.
+ intros. inv H. inv H0.
+ unfold load_stack, Val.add, loadv.
+ assert (Int.signed (Int.repr (fr_low fr)) = fr_low fr).
+ apply Int.signed_repr.
+ split. auto. apply Zle_trans with (-24). auto. compute; congruence.
+ assert (Int.signed (Int.add (Int.repr (fr_low fr)) ofs) = fr_low fr + Int.signed ofs).
+ rewrite int_add_no_overflow. rewrite H0. auto.
+ rewrite H0. split. omega. apply Zle_trans with 0.
+ generalize (AST.typesize_pos ty). omega. compute; congruence.
+ rewrite H9. apply H8. omega. auto.
+Qed.
+
+(** Assigning a value to a frame slot (in the abstract semantics)
+ corresponds to storing this value in the activation record
+ (in the concrete semantics). Moreover, agreement between frames
+ and activation records is preserved. *)
+
+Lemma frame_match_set_slot:
+ forall fr sp base mm ms ty ofs v fr',
+ frame_match fr sp base mm ms ->
+ set_slot fr ty (Int.signed ofs) v fr' ->
+ Val.has_type v ty ->
+ Mem.extends mm ms ->
+ exists ms',
+ store_stack ms (Vptr sp base) ty ofs v = Some ms' /\
+ frame_match fr' sp base mm ms' /\
+ Mem.extends mm ms' /\
+ Int.signed base + 24 <= Int.signed (Int.add base ofs).
+Proof.
+ intros. inv H. inv H0.
+ unfold store_stack, Val.add, storev.
+ assert (Int.signed (Int.repr (fr_low fr)) = fr_low fr).
+ apply Int.signed_repr.
+ split. auto. apply Zle_trans with (-24). auto. compute; congruence.
+ assert (Int.signed (Int.add (Int.repr (fr_low fr)) ofs) = fr_low fr + Int.signed ofs).
+ rewrite int_add_no_overflow. congruence.
+ rewrite H0. split. omega. apply Zle_trans with 0.
+ generalize (AST.typesize_pos ty). omega. compute; congruence.
+ rewrite H11.
+ assert (exists ms', store (chunk_of_type ty) ms sp (fr_low fr + Int.signed ofs) v = Some ms').
+ apply valid_access_store.
+ constructor. auto. omega.
+ rewrite size_type_chunk. omega.
+ destruct H12 as [ms' STORE].
+ generalize (low_bound_store _ _ _ _ _ _ STORE sp). intro LB.
+ generalize (high_bound_store _ _ _ _ _ _ STORE sp). intro HB.
+ exists ms'.
+ split. exact STORE.
+ (* frame match *)
+ split. constructor; simpl fr_low; try congruence.
+ eauto with mem. intros. simpl.
+ destruct (zeq (fr_low fr + Int.signed ofs) ofs0). subst ofs0.
+ destruct (typ_eq ty ty0). subst ty0.
+ (* same *)
+ transitivity (Some (Val.load_result (chunk_of_type ty) v)).
+ eapply load_store_same; eauto.
+ decEq. apply load_result_ty; auto.
+ (* mismatch *)
+ eapply load_store_mismatch'; eauto with mem.
+ destruct ty; destruct ty0; simpl; congruence.
+ destruct (zle (ofs0 + AST.typesize ty0) (fr_low fr + Int.signed ofs)).
+ (* disjoint *)
+ rewrite <- H10; auto. eapply load_store_other; eauto.
+ right; left. rewrite size_type_chunk; auto.
+ destruct (zle (fr_low fr + Int.signed ofs + AST.typesize ty)).
+ rewrite <- H10; auto. eapply load_store_other; eauto.
+ right; right. rewrite size_type_chunk; auto.
+ (* overlap *)
+ eapply load_store_overlap'; eauto with mem.
+ rewrite size_type_chunk; auto.
+ rewrite size_type_chunk; auto.
+ (* extends *)
+ split. eapply store_outside_extends; eauto.
+ left. rewrite size_type_chunk. omega.
+ (* bound *)
+ omega.
+Qed.
+
+(** Agreement is preserved by stores within blocks other than the
+ one pointed to by [sp], or to the low 24 bytes
+ of the [sp] block. *)
+
+Lemma frame_match_store_other:
+ forall fr sp base mm ms chunk b ofs v ms',
+ frame_match fr sp base mm ms ->
+ store chunk ms b ofs v = Some ms' ->
+ sp <> b \/ ofs + size_chunk chunk <= fr_low fr + 24 ->
+ frame_match fr sp base mm ms'.
+Proof.
+ intros. inv H.
+ generalize (low_bound_store _ _ _ _ _ _ H0 sp). intro LB.
+ generalize (high_bound_store _ _ _ _ _ _ H0 sp). intro HB.
+ apply frame_match_intro; auto.
+ eauto with mem.
+ congruence.
+ congruence.
+ intros. rewrite <- H9; auto.
+ eapply load_store_other; eauto.
+ elim H1; intro. auto. right. rewrite size_type_chunk. omega.
+Qed.
+
+Lemma frame_match_store:
+ forall fr sp base mm ms chunk b ofs v mm' ms',
+ frame_match fr sp base mm ms ->
+ store chunk mm b ofs v = Some mm' ->
+ store chunk ms b ofs v = Some ms' ->
+ frame_match fr sp base mm' ms'.
+Proof.
+ intros. inv H.
+ generalize (low_bound_store _ _ _ _ _ _ H0 sp). intro LBm.
+ generalize (low_bound_store _ _ _ _ _ _ H1 sp). intro LBs.
+ generalize (high_bound_store _ _ _ _ _ _ H0 sp). intro HBm.
+ generalize (high_bound_store _ _ _ _ _ _ H1 sp). intro HBs.
+ apply frame_match_intro; auto.
+ eauto with mem.
+ congruence. congruence. congruence.
+ intros. rewrite <- H9; auto. eapply load_store_other; eauto.
+ destruct (zeq sp b). subst b. right.
+ rewrite size_type_chunk.
+ assert (valid_access mm chunk sp ofs) by eauto with mem.
+ inv H10. left. omega.
+ auto.
+Qed.
+
+(** The low 24 bytes of a frame are preserved by a parallel
+ store in the two memory states. *)
+
+Lemma frame_match_store_link_invariant:
+ forall fr sp base mm ms chunk b ofs v mm' ms' ofs',
+ frame_match fr sp base mm ms ->
+ store chunk mm b ofs v = Some mm' ->
+ store chunk ms b ofs v = Some ms' ->
+ ofs' <= fr_low fr + 20 ->
+ load Mint32 ms' sp ofs' = load Mint32 ms sp ofs'.
+Proof.
+ intros. inv H.
+ eapply load_store_other; eauto.
+ destruct (eq_block sp b). subst b.
+ right; left. change (size_chunk Mint32) with 4.
+ assert (valid_access mm chunk sp ofs) by eauto with mem.
+ inv H. omega.
+ auto.
+Qed.
+
+(** Memory allocation of the Cminor stack data block (in the abstract
+ semantics) and of the whole activation record (in the concrete
+ semantics) return memory states that agree according to [frame_match].
+ Moreover, [frame_match] relations over already allocated blocks
+ remain true. *)
+
+Lemma frame_match_new:
+ forall mm ms mm' ms' sp sp' f,
+ mm.(nextblock) = ms.(nextblock) ->
+ alloc mm 0 f.(fn_stacksize) = (mm', sp) ->
+ alloc ms (- f.(fn_framesize)) (align_16_top (- f.(fn_framesize)) f.(fn_stacksize)) = (ms', sp') ->
+ f.(fn_framesize) >= 24 ->
+ f.(fn_framesize) <= -Int.min_signed ->
+ sp = sp' /\
+ frame_match (init_frame f) sp (Int.repr (-f.(fn_framesize))) mm' ms'.
+Proof.
+ intros.
+ assert (sp = sp').
+ exploit alloc_result. eexact H0. exploit alloc_result. eexact H1.
+ congruence.
+ subst sp'. split. auto.
+ generalize (low_bound_alloc_same _ _ _ _ _ H0). intro LBm.
+ generalize (low_bound_alloc_same _ _ _ _ _ H1). intro LBs.
+ generalize (high_bound_alloc_same _ _ _ _ _ H0). intro HBm.
+ generalize (high_bound_alloc_same _ _ _ _ _ H1). intro HBs.
+ constructor; simpl; eauto with mem.
+ rewrite HBs. apply Zle_ge. apply align_16_top_pos.
+ omega. omega.
+ intros.
+ eapply load_alloc_same'; eauto. omega.
+ rewrite size_type_chunk. apply Zle_trans with 0. auto.
+ apply align_16_top_pos.
+Qed.
+
+Lemma frame_match_alloc:
+ forall mm ms fr sp base lom him los his mm' ms' bm bs,
+ mm.(nextblock) = ms.(nextblock) ->
+ frame_match fr sp base mm ms ->
+ alloc mm lom him = (mm', bm) ->
+ alloc ms los his = (ms', bs) ->
+ frame_match fr sp base mm' ms'.
+Proof.
+ intros. inversion H0.
+ assert (valid_block mm sp). red. rewrite H. auto.
+ exploit low_bound_alloc_other. eexact H1. eexact H11. intro LBm.
+ exploit high_bound_alloc_other. eexact H1. eexact H11. intro HBm.
+ exploit low_bound_alloc_other. eexact H2. eexact H3. intro LBs.
+ exploit high_bound_alloc_other. eexact H2. eexact H3. intro HBs.
+ apply frame_match_intro.
+ eapply valid_block_alloc; eauto.
+ congruence. congruence. congruence. auto. auto. auto.
+ intros. eapply load_alloc_other; eauto.
+Qed.
+
+(** [frame_match] relations are preserved by freeing a block
+ other than the one pointed to by [sp]. *)
+
+Lemma frame_match_free:
+ forall fr sp base mm ms b,
+ frame_match fr sp base mm ms ->
+ sp <> b ->
+ frame_match fr sp base (free mm b) (free ms b).
+Proof.
+ intros. inversion H.
+ generalize (low_bound_free mm _ _ H0); intro LBm.
+ generalize (low_bound_free ms _ _ H0); intro LBs.
+ generalize (high_bound_free mm _ _ H0); intro HBm.
+ generalize (high_bound_free ms _ _ H0); intro HBs.
+ apply frame_match_intro; auto.
+ congruence. congruence. congruence.
+ intros. rewrite <- H8; auto. apply load_free. auto.
+Qed.
+
+(** ** Invariant for stacks *)
+
+Section SIMULATION.
+
+Variable p: program.
+Let ge := Genv.globalenv p.
+
+(** The [match_stacks] predicate relates a Machabstr call stack
+ with the corresponding Machconcr stack. In addition to enforcing
+ the [frame_match] predicate for each stack frame, we also enforce:
+- Proper chaining of activation record on the Machconcr side.
+- Preservation of the return address stored at the bottom of the
+ activation record.
+- Separation between the memory blocks holding the activation records:
+ their addresses increase strictly from caller to callee.
+*)
+
+Inductive match_stacks:
+ list Machabstr.stackframe -> list Machconcr.stackframe ->
+ block -> int -> mem -> mem -> Prop :=
+ | match_stacks_nil: forall sp base mm ms,
+ load Mint32 ms sp (Int.signed base) = Some (Vptr Mem.nullptr Int.zero) ->
+ load Mint32 ms sp (Int.signed base + 12) = Some Vzero ->
+ match_stacks nil nil sp base mm ms
+ | match_stacks_cons: forall f sp' base' c fr s fb ra ts sp base mm ms,
+ frame_match fr sp' base' mm ms ->
+ sp' < sp ->
+ load Mint32 ms sp (Int.signed base) = Some (Vptr sp' base') ->
+ load Mint32 ms sp (Int.signed base + 12) = Some ra ->
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ match_stacks s ts sp' base' mm ms ->
+ match_stacks (Machabstr.Stackframe f (Vptr sp' base') c fr :: s)
+ (Machconcr.Stackframe fb (Vptr sp' base') ra c :: ts)
+ sp base mm ms.
+
+Remark frame_match_base_eq:
+ forall fr sp base mm ms,
+ frame_match fr sp base mm ms -> Int.signed base = fr_low fr.
+Proof.
+ intros. inv H. apply Int.signed_repr. split; auto.
+ apply Zle_trans with (-24); auto. compute; congruence.
+Qed.
+
+(** If [match_stacks] holds, a lookup in the parent frame in the
+ Machabstr semantics corresponds to two memory loads in the
+ Machconcr semantics, one to load the pointer to the parent's
+ activation record, the second to read within this record. *)
+
+Lemma match_stacks_get_parent:
+ forall s ts sp base mm ms ty ofs v,
+ match_stacks s ts sp base mm ms ->
+ get_slot (parent_frame s) ty (Int.signed ofs) v ->
+ exists parent,
+ load_stack ms (Vptr sp base) Tint (Int.repr 0) = Some parent
+ /\ load_stack ms parent ty ofs = Some v.
+Proof.
+ intros. inv H; simpl in H0.
+ inv H0. simpl in H3. elimtype False. generalize (AST.typesize_pos ty). omega.
+ exists (Vptr sp' base'); split.
+ unfold load_stack. simpl. rewrite Int.add_zero. auto.
+ eapply frame_match_get_slot; eauto.
+Qed.
+
+(** If [match_stacks] holds, reading memory at offsets 0 and 12
+ from the stack pointer returns the stack pointer and return
+ address of the caller, respectively. *)
+
+Lemma match_stacks_load_links:
+ forall fr s ts sp base mm ms,
+ frame_match fr sp base mm ms ->
+ match_stacks s ts sp base mm ms ->
+ load_stack ms (Vptr sp base) Tint (Int.repr 0) = Some (parent_sp ts) /\
+ load_stack ms (Vptr sp base) Tint (Int.repr 12) = Some (parent_ra ts).
+Proof.
+ intros. unfold load_stack. simpl. rewrite Int.add_zero.
+ replace (Int.signed (Int.add base (Int.repr 12)))
+ with (Int.signed base + 12).
+ inv H0; simpl; auto.
+ inv H. rewrite Int.add_signed.
+ change (Int.signed (Int.repr 12)) with 12.
+ repeat rewrite Int.signed_repr. auto.
+ split. omega. apply Zle_trans with (-12). omega. compute; congruence.
+ split. auto. apply Zle_trans with (-24). auto. compute; congruence.
+Qed.
+
+(** The [match_stacks] invariant is preserved by memory stores
+ outside the 24-byte reserved area at the bottom of activation records.
+*)
+
+Lemma match_stacks_store_other:
+ forall s ts sp base ms mm,
+ match_stacks s ts sp base mm ms ->
+ forall chunk b ofs v ms',
+ store chunk ms b ofs v = Some ms' ->
+ sp < b ->
+ match_stacks s ts sp base mm ms'.
+Proof.
+ induction 1; intros.
+ assert (sp <> b). unfold block; omega.
+ constructor.
+ rewrite <- H. eapply load_store_other; eauto.
+ rewrite <- H0. eapply load_store_other; eauto.
+ assert (sp <> b). unfold block; omega.
+ econstructor; eauto.
+ eapply frame_match_store_other; eauto.
+ left. unfold block; omega.
+ rewrite <- H1. eapply load_store_other; eauto.
+ rewrite <- H2. eapply load_store_other; eauto.
+ eapply IHmatch_stacks; eauto. omega.
+Qed.
+
+Lemma match_stacks_store_slot:
+ forall s ts sp base ms mm,
+ match_stacks s ts sp base mm ms ->
+ forall ty ofs v ms',
+ store_stack ms (Vptr sp base) ty ofs v = Some ms' ->
+ Int.signed base + 24 <= Int.signed (Int.add base ofs) ->
+ match_stacks s ts sp base mm ms'.
+Proof.
+ intros.
+ unfold store_stack in H0. simpl in H0.
+ assert (load Mint32 ms' sp (Int.signed base) = load Mint32 ms sp (Int.signed base)).
+ eapply load_store_other; eauto.
+ right; left. change (size_chunk Mint32) with 4; omega.
+ assert (load Mint32 ms' sp (Int.signed base + 12) = load Mint32 ms sp (Int.signed base + 12)).
+ eapply load_store_other; eauto.
+ right; left. change (size_chunk Mint32) with 4; omega.
+ inv H.
+ constructor; congruence.
+ constructor; auto.
+ eapply frame_match_store_other; eauto.
+ left; unfold block; omega.
+ congruence. congruence.
+ eapply match_stacks_store_other; eauto.
+Qed.
+
+Lemma match_stacks_store:
+ forall s ts sp base ms mm,
+ match_stacks s ts sp base mm ms ->
+ forall fr chunk b ofs v mm' ms',
+ frame_match fr sp base mm ms ->
+ store chunk mm b ofs v = Some mm' ->
+ store chunk ms b ofs v = Some ms' ->
+ match_stacks s ts sp base mm' ms'.
+Proof.
+ induction 1; intros.
+ assert (Int.signed base = fr_low fr) by (eapply frame_match_base_eq; eauto).
+ constructor.
+ rewrite <- H. eapply frame_match_store_link_invariant; eauto. omega.
+ rewrite <- H0. eapply frame_match_store_link_invariant; eauto. omega.
+ assert (Int.signed base = fr_low fr0) by (eapply frame_match_base_eq; eauto).
+ econstructor; eauto.
+ eapply frame_match_store; eauto.
+ rewrite <- H1. eapply frame_match_store_link_invariant; eauto. omega.
+ rewrite <- H2. eapply frame_match_store_link_invariant; eauto. omega.
+Qed.
+
+Lemma match_stacks_alloc:
+ forall s ts sp base ms mm,
+ match_stacks s ts sp base mm ms ->
+ forall lom him mm' bm los his ms' bs,
+ mm.(nextblock) = ms.(nextblock) ->
+ alloc mm lom him = (mm', bm) ->
+ alloc ms los his = (ms', bs) ->
+ match_stacks s ts sp base mm' ms'.
+Proof.
+ induction 1; intros.
+ constructor.
+ rewrite <- H; eapply load_alloc_unchanged; eauto with mem.
+ rewrite <- H0; eapply load_alloc_unchanged; eauto with mem.
+ econstructor; eauto.
+ eapply frame_match_alloc; eauto.
+ rewrite <- H1; eapply load_alloc_unchanged; eauto with mem.
+ rewrite <- H2; eapply load_alloc_unchanged; eauto with mem.
+Qed.
+
+Lemma match_stacks_free:
+ forall s ts sp base ms mm,
+ match_stacks s ts sp base mm ms ->
+ forall b,
+ sp < b ->
+ match_stacks s ts sp base (Mem.free mm b) (Mem.free ms b).
+Proof.
+ induction 1; intros.
+ assert (sp <> b). unfold block; omega.
+ constructor.
+ rewrite <- H. apply load_free; auto.
+ rewrite <- H0. apply load_free; auto.
+ assert (sp <> b). unfold block; omega.
+ econstructor; eauto.
+ eapply frame_match_free; eauto. unfold block; omega.
+ rewrite <- H1. apply load_free; auto.
+ rewrite <- H2. apply load_free; auto.
+ eapply IHmatch_stacks; eauto. omega.
+Qed.
+
+(** Invocation of a function temporarily violates the [mach_stacks]
+ invariant: the return address and back link are not yet stored
+ in the appropriate parts of the activation record.
+ The following [match_stacks_partial] predicate is a weaker version
+ of [match_stacks] that captures this situation. *)
+
+Inductive match_stacks_partial:
+ list Machabstr.stackframe -> list Machconcr.stackframe ->
+ mem -> mem -> Prop :=
+ | match_stacks_partial_nil: forall mm ms,
+ match_stacks_partial nil nil mm ms
+ | match_stacks_partial_cons: forall f sp base c fr s fb ra ts mm ms,
+ frame_match fr sp base mm ms ->
+ sp < ms.(nextblock) ->
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ match_stacks s ts sp base mm ms ->
+ Val.has_type ra Tint ->
+ match_stacks_partial (Machabstr.Stackframe f (Vptr sp base) c fr :: s)
+ (Machconcr.Stackframe fb (Vptr sp base) ra c :: ts)
+ mm ms.
+
+Lemma match_stacks_match_stacks_partial:
+ forall s ts sp base mm ms,
+ match_stacks s ts sp base mm ms ->
+ match_stacks_partial s ts (free mm sp) (free ms sp).
+Proof.
+ intros. inv H. constructor.
+ econstructor.
+ eapply frame_match_free; eauto. unfold block; omega.
+ simpl. inv H0; auto.
+ auto.
+ apply match_stacks_free; auto.
+ generalize (Mem.load_inv _ _ _ _ _ H3). intros [A B].
+ rewrite B.
+ destruct (getN (pred_size_chunk Mint32) (Int.signed base + 12)
+ (contents (blocks ms sp))); exact I.
+Qed.
+
+Lemma match_stacks_function_entry:
+ forall s ts mm ms lom him mm' los his ms' stk ms'' ms''' base,
+ match_stacks_partial s ts mm ms ->
+ alloc mm lom him = (mm', stk) ->
+ alloc ms los his = (ms', stk) ->
+ store Mint32 ms' stk (Int.signed base) (parent_sp ts) = Some ms'' ->
+ store Mint32 ms'' stk (Int.signed base + 12) (parent_ra ts) = Some ms''' ->
+ match_stacks s ts stk base mm' ms'''.
+Proof.
+ intros.
+ assert (WT_SP: Val.has_type (parent_sp ts) Tint).
+ inv H; simpl; auto.
+ assert (WT_RA: Val.has_type (parent_ra ts) Tint).
+ inv H; simpl; auto.
+ assert (load Mint32 ms''' stk (Int.signed base) = Some (parent_sp ts)).
+ transitivity (load Mint32 ms'' stk (Int.signed base)).
+ eapply load_store_other; eauto. right; left. simpl. omega.
+ transitivity (Some (Val.load_result (chunk_of_type Tint) (parent_sp ts))).
+ simpl chunk_of_type. eapply load_store_same; eauto.
+ decEq. apply load_result_ty. auto.
+ assert (load Mint32 ms''' stk (Int.signed base + 12) = Some (parent_ra ts)).
+ transitivity (Some (Val.load_result (chunk_of_type Tint) (parent_ra ts))).
+ simpl chunk_of_type. eapply load_store_same; eauto.
+ decEq. apply load_result_ty. auto.
+ inv H; simpl in *.
+ constructor; auto.
+ assert (sp < stk). rewrite (alloc_result _ _ _ _ _ H1). auto.
+ assert (sp <> stk). unfold block; omega.
+ assert (nextblock mm = nextblock ms).
+ rewrite <- (alloc_result _ _ _ _ _ H0).
+ rewrite <- (alloc_result _ _ _ _ _ H1). auto.
+ econstructor; eauto.
+ eapply frame_match_store_other; eauto.
+ eapply frame_match_store_other; eauto.
+ eapply frame_match_alloc with (mm := mm) (ms := ms); eauto.
+ eapply match_stacks_store_other; eauto.
+ eapply match_stacks_store_other; eauto.
+ eapply match_stacks_alloc with (mm := mm) (ms := ms); eauto.
+ Qed.
+
+(** ** Invariant between states. *)
+
+(** The [match_state] predicate relates a Machabstr state with
+ a Machconcr state. In addition to [match_stacks] between the
+ stacks, we ask that
+- The Machabstr frame is properly stored in the activation record,
+ as characterized by [frame_match].
+- The Machconcr memory state extends the Machabstr memory state,
+ in the sense of the [Mem.extends] relation defined in module [Mem]. *)
+
+Inductive match_states:
+ Machabstr.state -> Machconcr.state -> Prop :=
+ | match_states_intro:
+ forall s f sp base c rs fr mm ts fb ms
+ (STACKS: match_stacks s ts sp base mm ms)
+ (FM: frame_match fr sp base mm ms)
+ (MEXT: Mem.extends mm ms)
+ (FIND: Genv.find_funct_ptr ge fb = Some (Internal f)),
+ match_states (Machabstr.State s f (Vptr sp base) c rs fr mm)
+ (Machconcr.State ts fb (Vptr sp base) c rs ms)
+ | match_states_call:
+ forall s f rs mm ts fb ms
+ (STACKS: match_stacks_partial s ts mm ms)
+ (MEXT: Mem.extends mm ms)
+ (FIND: Genv.find_funct_ptr ge fb = Some f),
+ match_states (Machabstr.Callstate s f rs mm)
+ (Machconcr.Callstate ts fb rs ms)
+ | match_states_return:
+ forall s rs mm ts ms
+ (STACKS: match_stacks_partial s ts mm ms)
+ (MEXT: Mem.extends mm ms),
+ match_states (Machabstr.Returnstate s rs mm)
+ (Machconcr.Returnstate ts rs ms).
+
+
+(** * The proof of simulation *)
+
+(** The proof of simulation relies on diagrams of the following form:
+<<
+ st1 --------------- st2
+ | |
+ t| |t
+ | |
+ v v
+ st1'--------------- st2'
+>>
+ The precondition is matching between the initial states [st1] and
+ [st2], as usual, plus the fact that [st1] is well-typed
+ in the sense of predicate [wt_state] from module [Machtyping].
+ The postcondition is matching between the final states [st1']
+ and [st2']. The well-typedness of [st2] is not part of the
+ postcondition, since it follows from that of [st1] if the
+ program is well-typed. (See the subject reduction property
+ in module [Machtyping].)
+*)
+
+Lemma find_function_find_function_ptr:
+ forall ros rs f',
+ find_function ge ros rs = Some f' ->
+ exists fb', Genv.find_funct_ptr ge fb' = Some f' /\ find_function_ptr ge ros rs = Some fb'.
+Proof.
+ intros until f'. destruct ros; simpl.
+ intro. exploit Genv.find_funct_inv; eauto. intros [fb' EQ].
+ rewrite EQ in H. rewrite Genv.find_funct_find_funct_ptr in H.
+ exists fb'; split. auto. rewrite EQ. simpl. auto.
+ destruct (Genv.find_symbol ge i); intro.
+ exists b; auto. congruence.
+Qed.
+
+(** Preservation of arguments to external functions. *)
+
+Lemma transl_extcall_arguments:
+ forall rs s sg args ts m ms,
+ Machabstr.extcall_arguments rs (parent_frame s) sg args ->
+ match_stacks_partial s ts m ms ->
+ extcall_arguments rs ms (parent_sp ts) sg args.
+Proof.
+ unfold Machabstr.extcall_arguments, extcall_arguments; intros.
+ assert (forall ty ofs v,
+ get_slot (parent_frame s) ty (Int.signed ofs) v ->
+ load_stack ms (parent_sp ts) ty ofs = Some v).
+ inv H0; simpl; intros.
+ inv H0. simpl in H2. elimtype False. generalize (AST.typesize_pos ty). omega.
+ eapply frame_match_get_slot; eauto.
+ assert (forall locs vals,
+ Machabstr.extcall_args rs (parent_frame s) locs vals ->
+ extcall_args rs ms (parent_sp ts) locs vals).
+ induction locs; intros; inversion H2; subst; clear H2.
+ constructor.
+ constructor; auto.
+ inversion H7; subst; clear H7.
+ constructor.
+ constructor. auto.
+ auto.
+Qed.
+
+Theorem step_equiv:
+ forall s1 t s2, Machabstr.step ge s1 t s2 ->
+ forall s1' (MS: match_states s1 s1') (WTS: wt_state s1),
+ exists s2', Machconcr.step ge s1' t s2' /\ match_states s2 s2'.
+Proof.
+ induction 1; intros; inv MS.
+
+ (* Mlabel *)
+ econstructor; split.
+ apply exec_Mlabel; auto.
+ econstructor; eauto with coqlib.
+
+ (* Mgetstack *)
+ exists (State ts fb (Vptr sp0 base) c (rs#dst <- v) ms); split.
+ apply exec_Mgetstack; auto. eapply frame_match_get_slot; eauto.
+ econstructor; eauto with coqlib.
+
+ (* Msetstack *)
+ assert (Val.has_type (rs src) ty).
+ inv WTS.
+ generalize (wt_function_instrs _ WTF _ (is_tail_in TAIL)); intro WTI.
+ inv WTI. apply WTRS.
+ exploit frame_match_set_slot; eauto.
+ intros [ms' [STORE [FM' [EXT' BOUND]]]].
+ exists (State ts fb (Vptr sp0 base) c rs ms'); split.
+ apply exec_Msetstack; auto.
+ econstructor; eauto.
+ eapply match_stacks_store_slot; eauto.
+
+ (* Mgetparam *)
+ exploit match_stacks_get_parent; eauto.
+ intros [parent [LOAD1 LOAD2]].
+ exists (State ts fb (Vptr sp0 base) c (rs#dst <- v) ms); split.
+ eapply exec_Mgetparam; eauto.
+ econstructor; eauto with coqlib.
+
+ (* Mop *)
+ exists (State ts fb (Vptr sp0 base) c (rs#res <- v) ms); split.
+ apply exec_Mop; auto.
+ eapply eval_operation_change_mem with (m := m); eauto.
+ intros. eapply Mem.valid_pointer_extends; eauto.
+ econstructor; eauto with coqlib.
+
+ (* Mload *)
+ exists (State ts fb (Vptr sp0 base) c (rs#dst <- v) ms); split.
+ eapply exec_Mload; eauto.
+ destruct a; simpl in H0; try discriminate.
+ simpl. eapply Mem.load_extends; eauto.
+ econstructor; eauto with coqlib.
+
+ (* Mstore *)
+ destruct a; simpl in H0; try discriminate.
+ exploit Mem.store_within_extends; eauto. intros [ms' [STORE MEXT']].
+ exists (State ts fb (Vptr sp0 base) c rs ms'); split.
+ eapply exec_Mstore; eauto.
+ econstructor; eauto with coqlib.
+ eapply match_stacks_store; eauto.
+ eapply frame_match_store; eauto.
+
+ (* Mcall *)
+ exploit find_function_find_function_ptr; eauto.
+ intros [fb' [FIND' FINDFUNCT]].
+ assert (exists ra', return_address_offset f c ra').
+ apply return_address_exists.
+ inv WTS. eapply is_tail_cons_left; eauto.
+ destruct H0 as [ra' RETADDR].
+ econstructor; split.
+ eapply exec_Mcall; eauto.
+ econstructor; eauto.
+ econstructor; eauto. inv FM; auto. exact I.
+
+ (* Mtailcall *)
+ exploit find_function_find_function_ptr; eauto.
+ intros [fb' [FIND' FINDFUNCT]].
+ exploit match_stacks_load_links; eauto. intros [LOAD1 LOAD2].
+ econstructor; split.
+ eapply exec_Mtailcall; eauto.
+ econstructor; eauto.
+ eapply match_stacks_match_stacks_partial; eauto.
+ apply free_extends; auto.
+
+ (* Malloc *)
+ caseEq (alloc ms 0 (Int.signed sz)). intros ms' blk' ALLOC.
+ exploit alloc_extends; eauto. omega. omega. intros [EQ MEXT']. subst blk'.
+ exists (State ts fb (Vptr sp0 base) c (rs#Conventions.loc_alloc_result <- (Vptr blk Int.zero)) ms'); split.
+ eapply exec_Malloc; eauto.
+ econstructor; eauto.
+ eapply match_stacks_alloc; eauto. inv MEXT; auto.
+ eapply frame_match_alloc with (mm := m) (ms := ms); eauto. inv MEXT; auto.
+
+ (* Mgoto *)
+ econstructor; split.
+ eapply exec_Mgoto; eauto.
+ econstructor; eauto.
+
+ (* Mcond *)
+ econstructor; split.
+ eapply exec_Mcond_true; eauto.
+ eapply eval_condition_change_mem with (m := m); eauto.
+ intros. eapply Mem.valid_pointer_extends; eauto.
+ econstructor; eauto.
+ econstructor; split.
+ eapply exec_Mcond_false; eauto.
+ eapply eval_condition_change_mem with (m := m); eauto.
+ intros. eapply Mem.valid_pointer_extends; eauto.
+ econstructor; eauto.
+
+ (* Mreturn *)
+ exploit match_stacks_load_links; eauto. intros [LOAD1 LOAD2].
+ econstructor; split.
+ eapply exec_Mreturn; eauto.
+ econstructor; eauto.
+ eapply match_stacks_match_stacks_partial; eauto.
+ apply free_extends; auto.
+
+ (* internal function *)
+ assert (WTF: wt_function f). inv WTS. inv H5. auto. inv WTF.
+ caseEq (alloc ms (- f.(fn_framesize))
+ (align_16_top (- f.(fn_framesize)) f.(fn_stacksize))).
+ intros ms' stk' ALLOC.
+ exploit (alloc_extends m ms m' ms' 0 (fn_stacksize f)
+ (- fn_framesize f)
+ (align_16_top (- fn_framesize f) (fn_stacksize f))); eauto.
+ omega. apply align_16_top_ge.
+ intros [EQ EXT']. subst stk'.
+ exploit (frame_match_new m ms); eauto. inv MEXT; auto.
+ intros [EQ FM]. clear EQ.
+ set (sp := Vptr stk (Int.repr (- fn_framesize f))).
+ assert (exists ms'', store Mint32 ms' stk (- fn_framesize f) (parent_sp ts) = Some ms'').
+ apply valid_access_store. constructor.
+ eauto with mem.
+ rewrite (low_bound_alloc_same _ _ _ _ _ ALLOC). omega.
+ rewrite (high_bound_alloc_same _ _ _ _ _ ALLOC).
+ change (size_chunk Mint32) with 4.
+ apply Zle_trans with 0. omega. apply align_16_top_pos.
+ destruct H0 as [ms'' STORE1].
+ assert (exists ms''', store Mint32 ms'' stk (- fn_framesize f + 12) (parent_ra ts) = Some ms''').
+ apply valid_access_store. constructor.
+ eauto with mem.
+ rewrite (low_bound_store _ _ _ _ _ _ STORE1 stk).
+ rewrite (low_bound_alloc_same _ _ _ _ _ ALLOC). omega.
+ rewrite (high_bound_store _ _ _ _ _ _ STORE1 stk).
+ rewrite (high_bound_alloc_same _ _ _ _ _ ALLOC).
+ change (size_chunk Mint32) with 4.
+ apply Zle_trans with 0. omega. apply align_16_top_pos.
+ destruct H0 as [ms''' STORE2].
+ assert (RANGE1: Int.min_signed <= - fn_framesize f <= Int.max_signed).
+ split. omega. apply Zle_trans with (-24). omega. compute;congruence.
+ assert (RANGE2: Int.min_signed <= - fn_framesize f + 12 <= Int.max_signed).
+ split. omega. apply Zle_trans with (-12). omega. compute;congruence.
+ econstructor; split.
+ eapply exec_function_internal; eauto.
+ unfold store_stack. simpl. rewrite Int.add_zero.
+ rewrite Int.signed_repr. eauto. auto.
+ unfold store_stack. simpl. rewrite Int.add_signed.
+ change (Int.signed (Int.repr 12)) with 12.
+ repeat rewrite Int.signed_repr; eauto.
+ (* match states *)
+ unfold sp; econstructor; eauto.
+ eapply match_stacks_function_entry; eauto.
+ rewrite Int.signed_repr; eauto.
+ rewrite Int.signed_repr; eauto.
+ eapply frame_match_store_other with (ms := ms''); eauto.
+ eapply frame_match_store_other with (ms := ms'); eauto.
+ simpl. right; omega. simpl. right; omega.
+ eapply store_outside_extends with (m2 := ms''); eauto.
+ eapply store_outside_extends with (m2 := ms'); eauto.
+ rewrite (low_bound_alloc_same _ _ _ _ _ H). simpl; omega.
+ rewrite (low_bound_alloc_same _ _ _ _ _ H). simpl; omega.
+
+ (* external function *)
+ econstructor; split.
+ eapply exec_function_external; eauto.
+ eapply transl_extcall_arguments; eauto.
+ econstructor; eauto.
+
+ (* return *)
+ inv STACKS.
+ econstructor; split.
+ eapply exec_return.
+ econstructor; eauto.
+Qed.
+
+Hypothesis wt_prog: wt_program p.
+
+Lemma equiv_initial_states:
+ forall st1, Machabstr.initial_state p st1 ->
+ exists st2, Machconcr.initial_state p st2 /\ match_states st1 st2 /\ wt_state st1.
+Proof.
+ intros. inversion H.
+ econstructor; split.
+ econstructor. eauto.
+ split. econstructor. constructor. apply Mem.extends_refl. auto.
+ econstructor. simpl; intros; contradiction.
+ eapply Genv.find_funct_ptr_prop; eauto.
+ red; intros; exact I.
+Qed.
+
+Lemma equiv_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 /\ wt_state st1 -> Machabstr.final_state st1 r -> Machconcr.final_state st2 r.
+Proof.
+ intros. inv H0. destruct H. inv H. inv STACKS.
+ constructor; auto.
+Qed.
+
+Theorem exec_program_equiv:
+ forall (beh: program_behavior),
+ Machabstr.exec_program p beh -> Machconcr.exec_program p beh.
+Proof.
+ unfold Machconcr.exec_program, Machabstr.exec_program; intros.
+ eapply simulation_step_preservation with
+ (step1 := Machabstr.step)
+ (step2 := Machconcr.step)
+ (match_states := fun st1 st2 => match_states st1 st2 /\ wt_state st1).
+ eexact equiv_initial_states.
+ eexact equiv_final_states.
+ intros. destruct H1. exploit step_equiv; eauto.
+ intros [st2' [A B]]. exists st2'; split. auto. split. auto.
+ eapply Machtyping.subject_reduction; eauto.
+ auto.
+Qed.
+
+End SIMULATION.
diff --git a/backend/Machabstr2mach.v b/backend/Machabstr2mach.v
deleted file mode 100644
index 8a2b01ddad523978c8e23b678ec5be1be3d49286..0000000000000000000000000000000000000000
--- a/backend/Machabstr2mach.v
+++ /dev/null
@@ -1,1185 +0,0 @@
-(** Simulation between the two semantics for the Mach language. *)
-
-Require Import Coqlib.
-Require Import Maps.
-Require Import AST.
-Require Import Integers.
-Require Import Values.
-Require Import Mem.
-Require Import Events.
-Require Import Globalenvs.
-Require Import Op.
-Require Import Locations.
-Require Import Machabstr.
-Require Import Mach.
-Require Import Machtyping.
-Require Import Stackingproof.
-
-(** Two semantics were defined for the Mach intermediate language:
-- The concrete semantics (file [Mach]), where the whole activation
- record resides in memory and the [Mgetstack], [Msetstack] and
- [Mgetparent] are interpreted as [sp]-relative memory accesses.
-- The abstract semantics (file [Machabstr]), where the activation
- record is split in two parts: the Cminor stack data, resident in
- memory, and the frame information, residing not in memory but
- in additional evaluation environments.
-
- In this file, we show a simulation result between these
- semantics: if a program executes to some result [r] in the
- abstract semantics, it also executes to the same result in
- the concrete semantics. This result bridges the correctness proof
- in file [Stackingproof] (which uses the abstract Mach semantics
- as output) and that in file [PPCgenproof] (which uses the concrete
- Mach semantics as input).
-*)
-
-Remark align_16_top_ge:
- forall lo hi,
- hi <= align_16_top lo hi.
-Proof.
- intros. unfold align_16_top. apply Zmax_bound_r.
- assert (forall x, x <= (x + 15) / 16 * 16).
- intro. assert (16 > 0). omega.
- generalize (Z_div_mod_eq (x + 15) 16 H). intro.
- replace ((x + 15) / 16 * 16) with ((x + 15) - (x + 15) mod 16).
- generalize (Z_mod_lt (x + 15) 16 H). omega.
- rewrite Zmult_comm. omega.
- generalize (H (hi - lo)). omega.
-Qed.
-
-Remark align_16_top_pos:
- forall lo hi,
- 0 <= align_16_top lo hi.
-Proof.
- intros. unfold align_16_top. apply Zmax_bound_l. omega.
-Qed.
-
-Remark size_mem_pos:
- forall sz, size_mem sz > 0.
-Proof.
- destruct sz; simpl; compute; auto.
-Qed.
-
-Remark size_type_chunk:
- forall ty, size_chunk (chunk_of_type ty) = 4 * typesize ty.
-Proof.
- destruct ty; reflexivity.
-Qed.
-
-Remark mem_chunk_type:
- forall ty, mem_chunk (chunk_of_type ty) = mem_type ty.
-Proof.
- destruct ty; reflexivity.
-Qed.
-
-Remark size_mem_type:
- forall ty, size_mem (mem_type ty) = 4 * typesize ty.
-Proof.
- destruct ty; reflexivity.
-Qed.
-
-(** * Agreement between frames and memory-resident activation records *)
-
-(** ** Agreement for one frame *)
-
-(** The core idea of the simulation proof is that for all active
- functions, the memory-allocated activation record, in the concrete
- semantics, contains the same data as the Cminor stack block
- (at positive offsets) and the frame of the function (at negative
- offsets) in the abstract semantics.
-
- This intuition (activation record = Cminor stack data + frame)
- is formalized by the following predicate [frame_match fr sp base mm ms].
- [fr] is a frame and [mm] the current memory state in the abstract
- semantics. [ms] is the current memory state in the concrete semantics.
- The stack pointer is [Vptr sp base] in both semantics. *)
-
-Inductive frame_match: frame -> block -> int -> mem -> mem -> Prop :=
- frame_match_intro:
- forall fr sp base mm ms,
- valid_block ms sp ->
- low_bound mm sp = 0 ->
- low_bound ms sp = fr.(low) ->
- high_bound ms sp = align_16_top fr.(low) (high_bound mm sp) ->
- fr.(low) <= 0 ->
- Int.min_signed <= fr.(low) ->
- base = Int.repr fr.(low) ->
- block_contents_agree fr.(low) 0 fr (ms.(blocks) sp) ->
- block_contents_agree 0 (high_bound ms sp)
- (mm.(blocks) sp) (ms.(blocks) sp) ->
- frame_match fr sp base mm ms.
-
-(** [frame_match], while presented as a relation for convenience,
- is actually a function: it fully determines the contents of the
- activation record [ms.(blocks) sp]. *)
-
-Lemma frame_match_exten:
- forall fr sp base mm ms1 ms2,
- frame_match fr sp base mm ms1 ->
- frame_match fr sp base mm ms2 ->
- ms1.(blocks) sp = ms2.(blocks) sp.
-Proof.
- intros. inversion H. inversion H0.
- unfold low_bound, high_bound in *.
- apply block_contents_exten.
- congruence.
- congruence.
- hnf; intros.
- elim H29. rewrite H3; rewrite H4; intros.
- case (zlt ofs 0); intro.
- assert (low fr <= ofs < 0). tauto.
- transitivity (contents fr ofs).
- symmetry. apply H8; auto.
- apply H22; auto.
- transitivity (contents (blocks mm sp) ofs).
- symmetry. apply H9. rewrite H4. omega.
- apply H23. rewrite H18. omega.
-Qed.
-
-(** The following two innocuous-looking lemmas are the key results
- showing that [sp]-relative memory accesses in the concrete
- semantics behave like the direct frame accesses in the abstract
- semantics. First, a value [v] that has type [ty] is preserved
- when stored in memory with chunk [chunk_of_type ty], then read
- back with the same chunk. The typing hypothesis is crucial here:
- for instance, a float value reads back as [Vundef] when stored
- and load with chunk [Mint32]. *)
-
-Lemma load_result_ty:
- forall v ty,
- Val.has_type v ty -> Val.load_result (chunk_of_type ty) v = v.
-Proof.
- destruct v; destruct ty; simpl; contradiction || reflexivity.
-Qed.
-
-(** Second, computations of [sp]-relative offsets using machine
- arithmetic (as done in the concrete semantics) never overflows
- and behaves identically to the offset computations using exact
- arithmetic (as done in the abstract semantics). *)
-
-Lemma int_add_no_overflow:
- forall x y,
- Int.min_signed <= Int.signed x + Int.signed y <= Int.max_signed ->
- Int.signed (Int.add x y) = Int.signed x + Int.signed y.
-Proof.
- intros. rewrite Int.add_signed. rewrite Int.signed_repr. auto. auto.
-Qed.
-
-(** Given matching frames and activation records, loading from the
- activation record (in the concrete semantics) behaves identically
- to reading the corresponding slot from the frame
- (in the abstract semantics). *)
-
-Lemma frame_match_get_slot:
- forall fr sp base mm ms ty ofs v,
- frame_match fr sp base mm ms ->
- get_slot fr ty (Int.signed ofs) v ->
- Val.has_type v ty ->
- load_stack ms (Vptr sp base) ty ofs = Some v.
-Proof.
- intros. inversion H. inversion H0. subst v.
- unfold load_stack, Val.add, loadv.
- assert (Int.signed base = low fr).
- rewrite H8. apply Int.signed_repr.
- split. auto. apply Zle_trans with 0. auto. compute; congruence.
- assert (Int.signed (Int.add base ofs) = low fr + Int.signed ofs).
- rewrite int_add_no_overflow. rewrite H18. auto.
- rewrite H18. split. omega. apply Zle_trans with 0.
- generalize (typesize_pos ty). omega. compute. congruence.
- rewrite H23.
- assert (BND1: low_bound ms sp <= low fr + Int.signed ofs).
- omega.
- assert (BND2: (low fr + Int.signed ofs) + size_chunk (chunk_of_type ty) <= high_bound ms sp).
- rewrite size_type_chunk. apply Zle_trans with 0.
- assumption. rewrite H5. apply align_16_top_pos.
- generalize (load_in_bounds (chunk_of_type ty) ms sp (low fr + Int.signed ofs) H2 BND1 BND2).
- intros [v' LOAD].
- generalize (load_inv _ _ _ _ _ LOAD).
- intros [A [B [C D]]].
- rewrite LOAD. rewrite <- D.
- decEq. rewrite mem_chunk_type.
- rewrite <- size_mem_type in H17.
- assert (low fr <= low fr + Int.signed ofs). omega.
- generalize (load_contentmap_agree _ _ _ _ _ _ H9 H24 H17).
- intro. rewrite H25.
- apply load_result_ty.
- assumption.
-Qed.
-
-(** Loads from [sp], corresponding to accesses to Cminor stack data
- in the abstract semantics, give the same results in the concrete
- semantics. This is because the offset from [sp] must be positive or
- null for the original load to succeed, and because the part
- of the activation record at positive offsets matches the Cminor
- stack data block. *)
-
-Lemma frame_match_load:
- forall fr sp base mm ms chunk ofs v,
- frame_match fr sp base mm ms ->
- load chunk mm sp ofs = Some v ->
- load chunk ms sp ofs = Some v.
-Proof.
- intros. inversion H.
- generalize (load_inv _ _ _ _ _ H0). intros [A [B [C D]]].
- change (low (blocks mm sp)) with (low_bound mm sp) in B.
- change (high (blocks mm sp)) with (high_bound mm sp) in C.
- unfold load. rewrite zlt_true; auto.
- rewrite in_bounds_holds.
- rewrite <- D. decEq. decEq. eapply load_contentmap_agree.
- red in H9. eexact H9.
- omega.
- unfold size_chunk in C. rewrite H4.
- apply Zle_trans with (high_bound mm sp). auto.
- apply align_16_top_ge.
- change (low (blocks ms sp)) with (low_bound ms sp).
- rewrite H3. omega.
- change (high (blocks ms sp)) with (high_bound ms sp).
- rewrite H4. apply Zle_trans with (high_bound mm sp). auto.
- apply align_16_top_ge.
-Qed.
-
-(** Assigning a value to a frame slot (in the abstract semantics)
- corresponds to storing this value in the activation record
- (in the concrete semantics). Moreover, agreement between frames
- and activation records is preserved. *)
-
-Lemma frame_match_set_slot:
- forall fr sp base mm ms ty ofs v fr',
- frame_match fr sp base mm ms ->
- set_slot fr ty (Int.signed ofs) v fr' ->
- exists ms',
- store_stack ms (Vptr sp base) ty ofs v = Some ms' /\
- frame_match fr' sp base mm ms'.
-Proof.
- intros. inversion H. inversion H0. subst ty0.
- unfold store_stack, Val.add, storev.
- assert (Int.signed base = low fr).
- rewrite H7. apply Int.signed_repr.
- split. auto. apply Zle_trans with 0. auto. compute; congruence.
- assert (Int.signed (Int.add base ofs) = low fr + Int.signed ofs).
- rewrite int_add_no_overflow. rewrite H16. auto.
- rewrite H16. split. omega. apply Zle_trans with 0.
- generalize (typesize_pos ty). omega. compute. congruence.
- rewrite H20.
- assert (BND1: low_bound ms sp <= low fr + Int.signed ofs).
- omega.
- assert (BND2: (low fr + Int.signed ofs) + size_chunk (chunk_of_type ty) <= high_bound ms sp).
- rewrite size_type_chunk. rewrite H4.
- apply Zle_trans with 0. subst ofs0. auto. apply align_16_top_pos.
- generalize (store_in_bounds _ _ _ _ v H1 BND1 BND2).
- intros [ms' STORE].
- generalize (store_inv _ _ _ _ _ _ STORE). intros [P [Q [R [S [x T]]]]].
- generalize (low_bound_store _ _ _ _ sp _ _ STORE). intro LB.
- generalize (high_bound_store _ _ _ _ sp _ _ STORE). intro HB.
- exists ms'.
- split. exact STORE.
- apply frame_match_intro; auto.
- eapply valid_block_store; eauto.
- rewrite LB. auto.
- rewrite HB. auto.
- red. rewrite T; rewrite update_s; simpl.
- rewrite mem_chunk_type.
- subst ofs0. eapply store_contentmap_agree; eauto.
- rewrite HB; rewrite T; rewrite update_s.
- red. simpl. apply store_contentmap_outside_agree.
- assumption. left. rewrite mem_chunk_type.
- rewrite size_mem_type. subst ofs0. auto.
-Qed.
-
-(** Agreement is preserved by stores within blocks other than the
- one pointed to by [sp]. *)
-
-Lemma frame_match_store_stack_other:
- forall fr sp base mm ms sp' base' ty ofs v ms',
- frame_match fr sp base mm ms ->
- store_stack ms (Vptr sp' base') ty ofs v = Some ms' ->
- sp <> sp' ->
- frame_match fr sp base mm ms'.
-Proof.
- unfold store_stack, Val.add, storev. intros. inversion H.
- generalize (store_inv _ _ _ _ _ _ H0). intros [P [Q [R [S [x T]]]]].
- generalize (low_bound_store _ _ _ _ sp _ _ H0). intro LB.
- generalize (high_bound_store _ _ _ _ sp _ _ H0). intro HB.
- apply frame_match_intro; auto.
- eapply valid_block_store; eauto.
- rewrite LB; auto.
- rewrite HB; auto.
- rewrite T; rewrite update_o; auto.
- rewrite HB; rewrite T; rewrite update_o; auto.
-Qed.
-
-(** Stores relative to [sp], corresponding to accesses to Cminor stack data
- in the abstract semantics, give the same results in the concrete
- semantics. Moreover, agreement between frames and activation
- records is preserved. *)
-
-Lemma frame_match_store_ok:
- forall fr sp base mm ms chunk ofs v mm',
- frame_match fr sp base mm ms ->
- store chunk mm sp ofs v = Some mm' ->
- exists ms', store chunk ms sp ofs v = Some ms'.
-Proof.
- intros. inversion H.
- generalize (store_inv _ _ _ _ _ _ H0). intros [P [Q [R [S [x T]]]]].
- change (low (blocks mm sp)) with (low_bound mm sp) in Q.
- change (high (blocks mm sp)) with (high_bound mm sp) in R.
- apply store_in_bounds.
- auto.
- omega.
- apply Zle_trans with (high_bound mm sp).
- auto. rewrite H4. apply align_16_top_ge.
-Qed.
-
-Lemma frame_match_store:
- forall fr sp base mm ms chunk b ofs v mm' ms',
- frame_match fr sp base mm ms ->
- store chunk mm b ofs v = Some mm' ->
- store chunk ms b ofs v = Some ms' ->
- frame_match fr sp base mm' ms'.
-Proof.
- intros. inversion H.
- generalize (store_inv _ _ _ _ _ _ H1). intros [A [B [C [D [x1 E]]]]].
- generalize (store_inv _ _ _ _ _ _ H0). intros [I [J [K [L [x2 M]]]]].
- generalize (low_bound_store _ _ _ _ sp _ _ H0). intro LBm.
- generalize (low_bound_store _ _ _ _ sp _ _ H1). intro LBs.
- generalize (high_bound_store _ _ _ _ sp _ _ H0). intro HBm.
- generalize (high_bound_store _ _ _ _ sp _ _ H1). intro HBs.
- apply frame_match_intro; auto.
- eapply valid_block_store; eauto.
- congruence. congruence. congruence.
- rewrite E. unfold update. case (zeq sp b); intro.
- subst b. red; simpl.
- apply store_contentmap_outside_agree; auto.
- right. unfold low_bound in H3. omega.
- assumption.
- rewrite HBs; rewrite E; rewrite M; unfold update.
- case (zeq sp b); intro.
- subst b. red; simpl.
- apply store_contentmap_agree; auto.
- assumption.
-Qed.
-
-(** Memory allocation of the Cminor stack data block (in the abstract
- semantics) and of the whole activation record (in the concrete
- semantics) return memory states that agree according to [frame_match].
- Moreover, [frame_match] relations over already allocated blocks
- remain true. *)
-
-Lemma frame_match_new:
- forall mm ms mm' ms' sp sp' f,
- mm.(nextblock) = ms.(nextblock) ->
- alloc mm 0 f.(fn_stacksize) = (mm', sp) ->
- alloc ms (- f.(fn_framesize)) (align_16_top (- f.(fn_framesize)) f.(fn_stacksize)) = (ms', sp') ->
- f.(fn_framesize) >= 0 ->
- f.(fn_framesize) <= -Int.min_signed ->
- frame_match (init_frame f) sp (Int.repr (-f.(fn_framesize))) mm' ms'.
-Proof.
- intros.
- injection H0; intros. injection H1; intros.
- assert (sp = sp'). congruence. rewrite <- H8 in H6. subst sp'.
- generalize (low_bound_alloc _ _ sp _ _ _ H0). rewrite zeq_true. intro LBm.
- generalize (low_bound_alloc _ _ sp _ _ _ H1). rewrite zeq_true. intro LBs.
- generalize (high_bound_alloc _ _ sp _ _ _ H0). rewrite zeq_true. intro HBm.
- generalize (high_bound_alloc _ _ sp _ _ _ H1). rewrite zeq_true. intro HBs.
- apply frame_match_intro; auto.
- eapply valid_new_block; eauto.
- simpl. congruence.
- simpl. omega.
- simpl. omega.
- rewrite <- H7. simpl. rewrite H6; simpl. rewrite update_s.
- hnf; simpl; auto.
- rewrite HBs; rewrite <- H5; simpl; rewrite H4; rewrite <- H7; simpl; rewrite H6; simpl;
- repeat (rewrite update_s).
- hnf; simpl; auto.
-Qed.
-
-Lemma frame_match_alloc:
- forall mm ms fr sp base lom him los his mm' ms' bm bs,
- mm.(nextblock) = ms.(nextblock) ->
- frame_match fr sp base mm ms ->
- alloc mm lom him = (mm', bm) ->
- alloc ms los his = (ms', bs) ->
- frame_match fr sp base mm' ms'.
-Proof.
- intros. inversion H0.
- assert (sp <> bm).
- apply valid_not_valid_diff with mm.
- red. rewrite H. exact H3.
- eapply fresh_block_alloc; eauto.
- assert (sp <> bs).
- apply valid_not_valid_diff with ms. auto.
- eapply fresh_block_alloc; eauto.
- generalize (low_bound_alloc _ _ sp _ _ _ H1).
- rewrite zeq_false; auto; intro LBm.
- generalize (low_bound_alloc _ _ sp _ _ _ H2).
- rewrite zeq_false; auto; intro LBs.
- generalize (high_bound_alloc _ _ sp _ _ _ H1).
- rewrite zeq_false; auto; intro HBm.
- generalize (high_bound_alloc _ _ sp _ _ _ H2).
- rewrite zeq_false; auto; intro HBs.
- apply frame_match_intro.
- eapply valid_block_alloc; eauto.
- congruence. congruence. congruence. auto. auto. auto.
- injection H2; intros. rewrite <- H20; simpl; rewrite H19; simpl.
- rewrite update_o; auto.
- rewrite HBs;
- injection H2; intros. rewrite <- H20; simpl; rewrite H19; simpl.
- injection H1; intros. rewrite <- H22; simpl; rewrite H21; simpl.
- repeat (rewrite update_o; auto).
-Qed.
-
-(** [frame_match] relations are preserved by freeing a block
- other than the one pointed to by [sp]. *)
-
-Lemma frame_match_free:
- forall fr sp base mm ms b,
- frame_match fr sp base mm ms ->
- sp <> b ->
- frame_match fr sp base (free mm b) (free ms b).
-Proof.
- intros. inversion H.
- generalize (low_bound_free mm _ _ H0); intro LBm.
- generalize (low_bound_free ms _ _ H0); intro LBs.
- generalize (high_bound_free mm _ _ H0); intro HBm.
- generalize (high_bound_free ms _ _ H0); intro HBs.
- apply frame_match_intro; auto.
- congruence. congruence. congruence.
- unfold free; simpl. rewrite update_o; auto.
- rewrite HBs.
- unfold free; simpl. repeat (rewrite update_o; auto).
-Qed.
-
-(** ** Agreement for all the frames in a call stack *)
-
-(** We need to reason about all the frames and activation records
- active at any given time during the executions: not just
- about those for the currently executing function, but also
- those for the callers. These collections of
- active frames are called ``call stacks''. They are lists
- of triples representing a frame and a stack pointer
- (reference and offset) in the abstract semantics. *)
-
-Definition callstack : Set := list (frame * block * int).
-
-(** The correct linking of frames (each frame contains a pointer
- to the frame of its caller at the lowest offset) is captured
- by the following predicate. *)
-
-Inductive callstack_linked: callstack -> Prop :=
- | callstack_linked_nil:
- callstack_linked nil
- | callstack_linked_one:
- forall fr1 sp1 base1,
- callstack_linked ((fr1, sp1, base1) :: nil)
- | callstack_linked_cons:
- forall fr1 sp1 base1 fr2 base2 sp2 cs,
- get_slot fr1 Tint 0 (Vptr sp2 base2) ->
- callstack_linked ((fr2, sp2, base2) :: cs) ->
- callstack_linked ((fr1, sp1, base1) :: (fr2, sp2, base2) :: cs).
-
-(** [callstack_dom cs b] (read: call stack [cs] is ``dominated''
- by block reference [b]) means that the stack pointers in [cs]
- strictly decrease and are all below [b]. This ensures that
- the stack block for a function was allocated after that for its
- callers. A consequence is that no two active functions share
- the same stack block. *)
-
-Inductive callstack_dom: callstack -> block -> Prop :=
- | callstack_dom_nil:
- forall b, callstack_dom nil b
- | callstack_dom_cons:
- forall fr sp base cs b,
- sp < b ->
- callstack_dom cs sp ->
- callstack_dom ((fr, sp, base) :: cs) b.
-
-Lemma callstack_dom_less:
- forall cs b, callstack_dom cs b ->
- forall fr sp base, In (fr, sp, base) cs -> sp < b.
-Proof.
- induction 1. simpl. tauto.
- simpl. intros fr0 sp0 base0 [A|B].
- injection A; intros; subst fr0; subst sp0; subst base0. auto.
- apply Zlt_trans with sp. eapply IHcallstack_dom; eauto. auto.
-Qed.
-
-Lemma callstack_dom_diff:
- forall cs b, callstack_dom cs b ->
- forall fr sp base, In (fr, sp, base) cs -> sp <> b.
-Proof.
- intros. apply Zlt_not_eq. eapply callstack_dom_less; eauto.
-Qed.
-
-Lemma callstack_dom_incr:
- forall cs b, callstack_dom cs b ->
- forall b', b < b' -> callstack_dom cs b'.
-Proof.
- induction 1; intros.
- apply callstack_dom_nil.
- apply callstack_dom_cons. omega. auto.
-Qed.
-
-(** Every block reference is either ``in'' a call stack (that is,
- refers to the stack block of one of the calls) or ``not in''
- a call stack (that is, differs from all the stack blocks). *)
-
-Inductive notin_callstack: block -> callstack -> Prop :=
- | notin_callstack_nil:
- forall b, notin_callstack b nil
- | notin_callstack_cons:
- forall b fr sp base cs,
- b <> sp ->
- notin_callstack b cs ->
- notin_callstack b ((fr, sp, base) :: cs).
-
-Lemma in_or_notin_callstack:
- forall b cs,
- (exists fr, exists base, In (fr, b, base) cs) \/ notin_callstack b cs.
-Proof.
- induction cs.
- right; constructor.
- elim IHcs.
- intros [fr [base IN]]. left. exists fr; exists base; auto with coqlib.
- intro NOTIN. destruct a. destruct p. case (eq_block b b0); intro.
- left. exists f; exists i. subst b0. auto with coqlib.
- right. apply notin_callstack_cons; auto.
-Qed.
-
-(** [callstack_invariant cs mm ms] relates the memory state [mm]
- from the abstract semantics with the memory state [ms] from the
- concrete semantics, relative to the current call stack [cs].
- Five conditions are enforced:
-- All frames in [cs] agree with the corresponding activation records
- (in the sense of [frame_match]).
-- The frames in the call stack are properly linked.
-- Memory blocks that are not activation records for active function
- calls are exactly identical in [mm] and [ms].
-- The allocation pointers are the same in [mm] and [ms].
-- The call stack [cs] is ``dominated'' by this allocation pointer,
- implying that all activation records are valid, allocated blocks,
- pairwise disjoint, and they were allocated in the order implied
- by [cs]. *)
-
-Record callstack_invariant (cs: callstack) (mm ms: mem) : Prop :=
- mk_callstack_invariant {
- cs_frame:
- forall fr sp base,
- In (fr, sp, base) cs -> frame_match fr sp base mm ms;
- cs_linked:
- callstack_linked cs;
- cs_others:
- forall b, notin_callstack b cs ->
- mm.(blocks) b = ms.(blocks) b;
- cs_next:
- mm.(nextblock) = ms.(nextblock);
- cs_dom:
- callstack_dom cs ms.(nextblock)
- }.
-
-(** Again, while [callstack_invariant] is presented as a relation,
- it actually fully determines the concrete memory state [ms]
- from the abstract memory state [mm] and the call stack [cs]. *)
-
-Lemma callstack_exten:
- forall cs mm ms1 ms2,
- callstack_invariant cs mm ms1 ->
- callstack_invariant cs mm ms2 ->
- ms1 = ms2.
-Proof.
- intros. inversion H; inversion H0.
- apply mem_exten.
- congruence.
- intros. elim (in_or_notin_callstack b cs).
- intros [fr [base FM]]. apply frame_match_exten with fr base mm; auto.
- intro. transitivity (blocks mm b).
- symmetry. auto. auto.
-Qed.
-
-(** The following properties of [callstack_invariant] are the
- building blocks for the proof of simulation. First, a [get_slot]
- operation in the abstract semantics corresponds to a [sp]-relative
- memory load in the concrete semantics. *)
-
-Lemma callstack_get_slot:
- forall fr sp base cs mm ms ty ofs v,
- callstack_invariant ((fr, sp, base) :: cs) mm ms ->
- get_slot fr ty (Int.signed ofs) v ->
- Val.has_type v ty ->
- load_stack ms (Vptr sp base) ty ofs = Some v.
-Proof.
- intros. inversion H.
- apply frame_match_get_slot with fr mm.
- apply cs_frame0. apply in_eq.
- auto. auto.
-Qed.
-
-(** Similarly, a [get_parent] operation corresponds to loading
- the back-link from the current activation record, then loading
- from this back-link. *)
-
-Lemma callstack_get_parent:
- forall fr1 sp1 base1 fr2 sp2 base2 cs mm ms ty ofs v,
- callstack_invariant ((fr1, sp1, base1) :: (fr2, sp2, base2) :: cs) mm ms ->
- get_slot fr2 ty (Int.signed ofs) v ->
- Val.has_type v ty ->
- load_stack ms (Vptr sp1 base1) Tint (Int.repr 0) = Some (Vptr sp2 base2) /\
- load_stack ms (Vptr sp2 base2) ty ofs = Some v.
-Proof.
- intros. inversion H. split.
- inversion cs_linked0.
- apply frame_match_get_slot with fr1 mm.
- apply cs_frame0. auto with coqlib.
- rewrite Int.signed_repr. auto. compute. intuition congruence.
- exact I.
- apply frame_match_get_slot with fr2 mm.
- apply cs_frame0. auto with coqlib.
- auto. auto.
-Qed.
-
-(** A memory load valid in the abstract semantics can also be performed
- in the concrete semantics. *)
-
-Lemma callstack_load:
- forall cs chunk mm ms a v,
- callstack_invariant cs mm ms ->
- loadv chunk mm a = Some v ->
- loadv chunk ms a = Some v.
-Proof.
- unfold loadv. intros. destruct a; try discriminate.
- inversion H.
- elim (in_or_notin_callstack b cs).
- intros [fr [base IN]]. apply frame_match_load with fr base mm; auto.
- intro. rewrite <- H0. unfold load.
- rewrite (cs_others0 b H1). rewrite cs_next0. reflexivity.
-Qed.
-
-(** A [set_slot] operation in the abstract semantics corresponds
- to a [sp]-relative memory store in the concrete semantics.
- Moreover, the property [callstack_invariant] still holds for
- the final call stacks and memory states. *)
-
-Lemma callstack_set_slot:
- forall fr sp base cs mm ms ty ofs v fr',
- callstack_invariant ((fr, sp, base) :: cs) mm ms ->
- set_slot fr ty (Int.signed ofs) v fr' ->
- 4 <= Int.signed ofs ->
- exists ms',
- store_stack ms (Vptr sp base) ty ofs v = Some ms' /\
- callstack_invariant ((fr', sp, base) :: cs) mm ms'.
-Proof.
- intros. inversion H.
- assert (frame_match fr sp base mm ms). apply cs_frame0. apply in_eq.
- generalize (frame_match_set_slot _ _ _ _ _ _ _ _ _ H2 H0).
- intros [ms' [SS FM]].
- generalize (store_inv _ _ _ _ _ _ SS). intros [A [B [C [D [x E]]]]].
- exists ms'.
- split. auto.
- constructor.
- (* cs_frame *)
- intros. elim H3; intros.
- injection H4; intros; clear H4.
- subst fr0; subst sp0; subst base0. auto.
- apply frame_match_store_stack_other with ms sp base ty ofs v.
- apply cs_frame0. auto with coqlib. auto.
- apply callstack_dom_diff with cs fr0 base0. inversion cs_dom0; auto. auto.
- (* cs_linked *)
- inversion cs_linked0. apply callstack_linked_one.
- apply callstack_linked_cons.
- eapply slot_gso; eauto.
- auto.
- (* cs_others *)
- intros. inversion H3.
- rewrite E; simpl. rewrite update_o; auto. apply cs_others0.
- constructor; auto.
- (* cs_next *)
- congruence.
- (* cs_dom *)
- inversion cs_dom0. constructor. rewrite D; auto. auto.
-Qed.
-
-(** A memory store in the abstract semantics can also be performed
- in the concrete semantics. Moreover, the property
- [callstack_invariant] is preserved. *)
-
-Lemma callstack_store_aux:
- forall cs mm ms chunk b ofs v mm' ms',
- callstack_invariant cs mm ms ->
- store chunk mm b ofs v = Some mm' ->
- store chunk ms b ofs v = Some ms' ->
- callstack_invariant cs mm' ms'.
-Proof.
- intros. inversion H.
- generalize (store_inv _ _ _ _ _ _ H0). intros [A [B [C [D [x E]]]]].
- generalize (store_inv _ _ _ _ _ _ H1). intros [P [Q [R [S [y T]]]]].
- constructor; auto.
- (* cs_frame *)
- intros. eapply frame_match_store; eauto.
- (* cs_others *)
- intros. generalize (cs_others0 b0 H2); intro.
- rewrite E; rewrite T; unfold update.
- case (zeq b0 b); intro.
- subst b0.
- generalize x; generalize y. rewrite H3.
- intros. replace y0 with x0. reflexivity. apply proof_irrelevance.
- auto.
- (* cs_nextblock *)
- congruence.
- (* cs_dom *)
- rewrite S. auto.
-Qed.
-
-Lemma callstack_store_ok:
- forall cs mm ms chunk b ofs v mm',
- callstack_invariant cs mm ms ->
- store chunk mm b ofs v = Some mm' ->
- exists ms', store chunk ms b ofs v = Some ms'.
-Proof.
- intros. inversion H.
- elim (in_or_notin_callstack b cs).
- intros [fr [base IN]].
- apply frame_match_store_ok with fr base mm mm'; auto.
- intro. generalize (cs_others0 b H1). intro.
- generalize (store_inv _ _ _ _ _ _ H0).
- rewrite cs_next0; rewrite H2. intros [A [B [C [D [x E]]]]].
- apply store_in_bounds; auto.
-Qed.
-
-Lemma callstack_store:
- forall cs mm ms chunk a v mm',
- callstack_invariant cs mm ms ->
- storev chunk mm a v = Some mm' ->
- exists ms',
- storev chunk ms a v = Some ms' /\
- callstack_invariant cs mm' ms'.
-Proof.
- unfold storev; intros. destruct a; try discriminate.
- generalize (callstack_store_ok _ _ _ _ _ _ _ _ H H0).
- intros [ms' STORE].
- exists ms'. split. auto. eapply callstack_store_aux; eauto.
-Qed.
-
-(** Allocations of heap blocks can be performed in parallel in
- both semantics, preserving [callstack_invariant]. *)
-
-Lemma callstack_alloc:
- forall cs mm ms lo hi mm' blk,
- callstack_invariant cs mm ms ->
- Mem.alloc mm lo hi = (mm', blk) ->
- exists ms',
- Mem.alloc ms lo hi = (ms', blk) /\
- callstack_invariant cs mm' ms'.
-Proof.
- intros. inversion H.
- caseEq (alloc ms lo hi). intros ms' blk' ALLOC'.
- injection H0; intros. injection ALLOC'; intros.
- assert (blk' = blk). congruence. rewrite H5 in H3. rewrite H5.
- exists ms'; split. auto.
- constructor.
- (* frame *)
- intros; eapply frame_match_alloc; eauto.
- (* linked *)
- auto.
- (* others *)
- intros. rewrite <- H2; rewrite <- H4; simpl.
- rewrite H1; rewrite H3. unfold update. case (zeq b blk); auto.
- (* next *)
- rewrite <- H2; rewrite <- H4; simpl; congruence.
- (* dom *)
- eapply callstack_dom_incr; eauto. rewrite <- H4; simpl. omega.
-Qed.
-
-(** At function entry, a new frame is pushed on the call stack,
- and memory blocks are allocated in both semantics. Moreover,
- the back link to the caller's activation record is set up
- in the concrete semantics. All this preserves [callstack_invariant]. *)
-
-Lemma callstack_function_entry:
- forall fr0 sp0 base0 cs mm ms f fr mm' sp ms' sp',
- callstack_invariant ((fr0, sp0, base0) :: cs) mm ms ->
- alloc mm 0 f.(fn_stacksize) = (mm', sp) ->
- alloc ms (- f.(fn_framesize)) (align_16_top (- f.(fn_framesize)) f.(fn_stacksize)) = (ms', sp') ->
- f.(fn_framesize) >= 0 ->
- f.(fn_framesize) <= -Int.min_signed ->
- set_slot (init_frame f) Tint 0 (Vptr sp0 base0) fr ->
- let base := Int.repr (-f.(fn_framesize)) in
- exists ms'',
- store_stack ms' (Vptr sp base) Tint (Int.repr 0) (Vptr sp0 base0) = Some ms''
- /\ callstack_invariant ((fr, sp, base) :: (fr0, sp0, base0) :: cs) mm' ms''
- /\ sp' = sp.
-Proof.
- assert (ZERO: 0 = Int.signed (Int.repr 0)).
- rewrite Int.signed_repr. auto. compute; intuition congruence.
- intros. inversion H.
- injection H0; intros. injection H1; intros.
- assert (sp' = sp). congruence. rewrite H9 in H7. subst sp'.
- assert (frame_match (init_frame f) sp base mm' ms').
- unfold base. eapply frame_match_new; eauto.
- rewrite ZERO in H4.
- generalize (frame_match_set_slot _ _ _ _ _ _ _ _ _ H9 H4).
- intros [ms'' [SS FM]].
- generalize (store_inv _ _ _ _ _ _ SS).
- intros [A [B [C [D [x E]]]]].
- exists ms''. split; auto. split.
- constructor.
- (* cs_frame *)
- intros. elim H10; intro.
- injection H11; intros; clear H11.
- subst fr1; subst sp1; subst base1. auto.
- eapply frame_match_store_stack_other; eauto.
- eapply frame_match_alloc; [idtac|idtac|eexact H0|eexact H1].
- congruence. eapply cs_frame; eauto with coqlib.
- rewrite <- H7. eapply callstack_dom_diff; eauto with coqlib.
- (* cs_linked *)
- constructor. rewrite ZERO. eapply slot_gss; eauto. auto.
- (* cs_others *)
- intros. inversion H10.
- rewrite E; rewrite update_o; auto.
- rewrite <- H6; rewrite <- H8; simpl; rewrite H5; rewrite H7; simpl.
- repeat (rewrite update_o; auto).
- (* cs_next *)
- rewrite D. rewrite <- H6; rewrite <- H8; simpl. congruence.
- (* cs_dom *)
- constructor. rewrite D; auto. rewrite <- H7. auto.
- auto.
-Qed.
-
-(** At function return, the memory blocks corresponding to Cminor
- stack data and activation record for the function are freed.
- This preserves [callstack_invariant]. *)
-
-Lemma callstack_function_return:
- forall fr sp base cs mm ms,
- callstack_invariant ((fr, sp, base) :: cs) mm ms ->
- callstack_invariant cs (free mm sp) (free ms sp).
-Proof.
- intros. inversion H. inversion cs_dom0.
- constructor.
- (* cs_frame *)
- intros. apply frame_match_free. apply cs_frame0; auto with coqlib.
- apply callstack_dom_diff with cs fr1 base1. auto. auto.
- (* cs_linked *)
- inversion cs_linked0. apply callstack_linked_nil. auto.
- (* cs_others *)
- intros.
- unfold free; simpl; unfold update.
- case (zeq b0 sp); intro.
- auto.
- apply cs_others0. apply notin_callstack_cons; auto.
- (* cs_nextblock *)
- simpl. auto.
- (* cs_dom *)
- simpl. apply callstack_dom_incr with sp; auto.
-Qed.
-
-(** Finally, [callstack_invariant] holds for the initial memory states
- in the two semantics. *)
-
-Lemma callstack_init:
- forall (p: program),
- callstack_invariant ((empty_frame, nullptr, Int.zero) :: nil)
- (Genv.init_mem p) (Genv.init_mem p).
-Proof.
- intros.
- generalize (Genv.initmem_nullptr p). intros [A B].
- constructor.
- (* cs_frame *)
- intros. elim H; intro.
- injection H0; intros; subst fr; subst sp; subst base.
- constructor.
- assumption.
- unfold low_bound. rewrite B. reflexivity.
- unfold low_bound, empty_frame. rewrite B. reflexivity.
- unfold high_bound. rewrite B. reflexivity.
- simpl. omega.
- simpl. compute. intuition congruence.
- reflexivity.
- rewrite B. unfold empty_frame. simpl. hnf. auto.
- rewrite B. hnf. auto.
- elim H0.
- (* cs_linked *)
- apply callstack_linked_one.
- (* cs_others *)
- auto.
- (* cs_nextblock *)
- reflexivity.
- (* cs_dom *)
- constructor. exact A. constructor.
-Qed.
-
-(** Preservation of arguments to external functions. *)
-
-Lemma transl_extcall_arguments:
- forall rs fr sg args stk base cs m ms,
- Machabstr.extcall_arguments rs fr sg args ->
- callstack_invariant ((fr, stk, base) :: cs) m ms ->
- wt_frame fr ->
- extcall_arguments rs ms (Vptr stk base) sg args.
-Proof.
- unfold Machabstr.extcall_arguments, extcall_arguments; intros.
- assert (forall locs vals,
- Machabstr.extcall_args rs fr locs vals ->
- extcall_args rs ms (Vptr stk base) locs vals).
- induction locs; intros; inversion H2; subst; clear H2.
- constructor.
- constructor; auto.
- inversion H7; subst; clear H7.
- constructor.
- constructor. eapply callstack_get_slot; eauto.
- eapply wt_get_slot; eauto.
- auto.
-Qed.
-
-(** * The proof of simulation *)
-
-Section SIMULATION.
-
-Variable p: program.
-Hypothesis wt_p: wt_program p.
-Let ge := Genv.globalenv p.
-
-(** The proof of simulation relies on diagrams of the following form:
-<<
- sp, parent, c, rs, fr, mm ----------- sp, c, rs, ms
- | |
- | |
- v v
- sp, parent, c', rs', fr', mm' -------- sp, c', rs', ms'
->>
- The left vertical arrow is a transition in the abstract semantics.
- The right vertical arrow is a transition in the concrete semantics.
- The precondition (top horizontal line) is the appropriate
- [callstack_invariant] property between the initial memory states
- [mm] and [ms] and any call stack with [fr] as top frame and
- [parent] as second frame. In addition, well-typedness conditions
- over the code [c], the register [rs] and the frame [fr] are demanded.
- The postcondition (bottom horizontal line) is [callstack_invariant]
- between the final memory states [mm'] and [ms'] and the final
- call stack.
-*)
-
-Definition exec_instr_prop
- (f: function) (sp: val) (parent: frame)
- (c: code) (rs: regset) (fr: frame) (mm: mem) (t: trace)
- (c': code) (rs': regset) (fr': frame) (mm': mem) : Prop :=
- forall ms stk base pstk pbase cs
- (WTF: wt_function f)
- (INCL: incl c f.(fn_code))
- (WTRS: wt_regset rs)
- (WTFR: wt_frame fr)
- (WTPA: wt_frame parent)
- (CSI: callstack_invariant ((fr, stk, base) :: (parent, pstk, pbase) :: cs) mm ms)
- (SP: sp = Vptr stk base),
- exists ms',
- exec_instr ge f sp c rs ms t c' rs' ms' /\
- callstack_invariant ((fr', stk, base) :: (parent, pstk, pbase) :: cs) mm' ms'.
-
-Definition exec_instrs_prop
- (f: function) (sp: val) (parent: frame)
- (c: code) (rs: regset) (fr: frame) (mm: mem) (t: trace)
- (c': code) (rs': regset) (fr': frame) (mm': mem) : Prop :=
- forall ms stk base pstk pbase cs
- (WTF: wt_function f)
- (INCL: incl c f.(fn_code))
- (WTRS: wt_regset rs)
- (WTFR: wt_frame fr)
- (WTPA: wt_frame parent)
- (CSI: callstack_invariant ((fr, stk, base) :: (parent, pstk, pbase) :: cs) mm ms)
- (SP: sp = Vptr stk base),
- exists ms',
- exec_instrs ge f sp c rs ms t c' rs' ms' /\
- callstack_invariant ((fr', stk, base) :: (parent, pstk, pbase) :: cs) mm' ms'.
-
-Definition exec_function_body_prop
- (f: function) (parent: frame) (link ra: val)
- (rs: regset) (mm: mem) (t: trace)
- (rs': regset) (mm': mem) : Prop :=
- forall ms pstk pbase cs
- (WTF: wt_function f)
- (WTRS: wt_regset rs)
- (WTPA: wt_frame parent)
- (WTRA: Val.has_type ra Tint)
- (LINK: link = Vptr pstk pbase)
- (CSI: callstack_invariant ((parent, pstk, pbase) :: cs) mm ms),
- exists ms',
- exec_function_body ge f (Vptr pstk pbase) ra rs ms t rs' ms' /\
- callstack_invariant ((parent, pstk, pbase) :: cs) mm' ms'.
-
-Definition exec_function_prop
- (f: fundef) (parent: frame)
- (rs: regset) (mm: mem) (t: trace)
- (rs': regset) (mm': mem) : Prop :=
- forall ms pstk pbase cs
- (WTF: wt_fundef f)
- (WTRS: wt_regset rs)
- (WTPA: wt_frame parent)
- (CSI: callstack_invariant ((parent, pstk, pbase) :: cs) mm ms),
- exists ms',
- exec_function ge f (Vptr pstk pbase) rs ms t rs' ms' /\
- callstack_invariant ((parent, pstk, pbase) :: cs) mm' ms'.
-
-Lemma exec_function_equiv:
- forall f parent rs mm t rs' mm',
- Machabstr.exec_function ge f parent rs mm t rs' mm' ->
- exec_function_prop f parent rs mm t rs' mm'.
-Proof.
- apply (Machabstr.exec_function_ind4 ge
- exec_instr_prop
- exec_instrs_prop
- exec_function_body_prop
- exec_function_prop);
- intros; red; intros.
-
- (* Mlabel *)
- exists ms. split. constructor. auto.
- (* Mgetstack *)
- exists ms. split.
- constructor. rewrite SP. eapply callstack_get_slot; eauto.
- apply wt_get_slot with fr (Int.signed ofs); auto.
- auto.
- (* Msetstack *)
- generalize (wt_function_instrs f WTF _ (INCL _ (in_eq _ _))).
- intro WTI. inversion WTI.
- assert (4 <= Int.signed ofs). omega.
- generalize (callstack_set_slot _ _ _ _ _ _ _ _ _ _ CSI H H5).
- intros [ms' [STO CSI']].
- exists ms'. split. constructor. rewrite SP. auto. auto.
- (* Mgetparam *)
- exists ms. split.
- assert (WTV: Val.has_type v ty). eapply wt_get_slot; eauto.
- generalize (callstack_get_parent _ _ _ _ _ _ _ _ _ _ _ _
- CSI H WTV).
- intros [L1 L2].
- eapply exec_Mgetparam. rewrite SP; eexact L1. eexact L2.
- auto.
- (* Mop *)
- exists ms. split. constructor. auto. auto.
- (* Mload *)
- exists ms. split. econstructor. eauto. eapply callstack_load; eauto.
- auto.
- (* Mstore *)
- generalize (callstack_store _ _ _ _ _ _ _ CSI H0).
- intros [ms' [STO CSI']].
- exists ms'. split. econstructor. eauto. auto.
- auto.
- (* Mcall *)
- red in H1.
- assert (WTF': wt_fundef f').
- destruct ros; simpl in H.
- apply (Genv.find_funct_prop wt_fundef wt_p H).
- destruct (Genv.find_symbol ge i); try discriminate.
- apply (Genv.find_funct_ptr_prop wt_fundef wt_p H).
- generalize (H1 _ _ _ _ WTF' WTRS WTFR CSI).
- intros [ms' [EXF CSI']].
- exists ms'. split. apply exec_Mcall with f'; auto.
- rewrite SP. auto.
- auto.
- (* Malloc *)
- generalize (callstack_alloc _ _ _ _ _ _ _ CSI H0).
- intros [ms' [ALLOC' CSI']].
- exists ms'; split.
- eapply exec_Malloc; eauto.
- auto.
- (* Mgoto *)
- exists ms. split. constructor; auto. auto.
- (* Mcond *)
- exists ms. split. apply exec_Mcond_true; auto. auto.
- exists ms. split. apply exec_Mcond_false; auto. auto.
-
- (* refl *)
- exists ms. split. apply exec_refl. auto.
- (* one *)
- generalize (H0 _ _ _ _ _ _ WTF INCL WTRS WTFR WTPA CSI SP).
- intros [ms' [EX CSI']].
- exists ms'. split. apply exec_one; auto. auto.
- (* trans *)
- generalize (subject_reduction_instrs p wt_p
- _ _ _ _ _ _ _ _ _ _ _ _ H WTF INCL WTRS WTFR WTPA).
- intros [INCL2 [WTRS2 WTFR2]].
- generalize (H0 _ _ _ _ _ _ WTF INCL WTRS WTFR WTPA CSI SP).
- intros [ms1 [EX1 CSI1]].
- generalize (H2 _ _ _ _ _ _ WTF INCL2 WTRS2 WTFR2 WTPA CSI1 SP).
- intros [ms2 [EX2 CSI2]].
- exists ms2. split. eapply exec_trans; eauto. auto.
-
- (* function body *)
- caseEq (alloc ms (- f.(fn_framesize))
- (align_16_top (- f.(fn_framesize)) f.(fn_stacksize))).
- intros ms1 stk1 ALL.
- subst link.
- assert (FS: f.(fn_framesize) >= 0).
- generalize (wt_function_framesize f WTF). omega.
- generalize (callstack_function_entry _ _ _ _ _ _ _ _ _ _ _ _
- CSI H ALL FS
- (wt_function_no_overflow f WTF) H0).
- intros [ms2 [STORELINK [CSI2 EQ]]].
- subst stk1.
- assert (ZERO: Int.signed (Int.repr 0) = 0). reflexivity.
- assert (TWELVE: Int.signed (Int.repr 12) = 12). reflexivity.
- assert (BND: 4 <= Int.signed (Int.repr 12)).
- rewrite TWELVE; omega.
- rewrite <- TWELVE in H1.
- generalize (callstack_set_slot _ _ _ _ _ _ _ _ _ _
- CSI2 H1 BND).
- intros [ms3 [STORERA CSI3]].
- assert (WTFR2: wt_frame fr2).
- eapply wt_set_slot; eauto. eapply wt_set_slot; eauto.
- red. intros. simpl. auto.
- exact I.
- red in H3.
- generalize (H3 _ _ _ _ _ _ WTF (incl_refl _) WTRS WTFR2 WTPA
- CSI3 (refl_equal _)).
- intros [ms4 [EXEC CSI4]].
- generalize (exec_instrs_link_invariant _ _ _ _ _ _ _ _ _ _ _ _ _
- H2 WTF (incl_refl _)).
- intros [INCL LINKINV].
- exists (free ms4 stk). split.
- eapply exec_funct_body; eauto.
- eapply callstack_get_slot. eexact CSI4.
- apply LINKINV. rewrite ZERO. omega.
- eapply slot_gso; eauto. rewrite ZERO. eapply slot_gss; eauto.
- exact I.
- eapply callstack_get_slot. eexact CSI4.
- apply LINKINV. rewrite TWELVE. omega. eapply slot_gss; eauto. auto.
- eapply callstack_function_return; eauto.
-
- (* internal function *)
- inversion WTF. subst f0.
- generalize (H0 (Vptr pstk pbase) Vzero I I
- ms pstk pbase cs H2 WTRS WTPA I (refl_equal _) CSI).
- intros [ms' [EXEC CSI']].
- exists ms'. split. constructor. intros.
- generalize (H0 (Vptr pstk pbase) ra I H1
- ms pstk pbase cs H2 WTRS WTPA H1 (refl_equal _) CSI).
- intros [ms1 [EXEC1 CSI1]].
- rewrite (callstack_exten _ _ _ _ CSI' CSI1). auto.
- auto.
-
- (* external function *)
- exists ms; split. econstructor; eauto.
- eapply transl_extcall_arguments; eauto.
- auto.
-Qed.
-
-End SIMULATION.
-
-Theorem exec_program_equiv:
- forall p t r,
- wt_program p ->
- Machabstr.exec_program p t r ->
- Mach.exec_program p t r.
-Proof.
- intros p t r WTP [fptr [f [rs [mm [FINDPTR [FINDF [EXEC RES]]]]]]].
- assert (WTF: wt_fundef f).
- apply (Genv.find_funct_ptr_prop wt_fundef WTP FINDF).
- assert (WTRS: wt_regset (Regmap.init Vundef)).
- red; intros. rewrite Regmap.gi; simpl; auto.
- assert (WTFR: wt_frame empty_frame).
- red; intros. simpl. auto.
- generalize (exec_function_equiv p WTP
- f empty_frame
- (Regmap.init Vundef) (Genv.init_mem p) t rs mm
- EXEC (Genv.init_mem p) nullptr Int.zero nil
- WTF WTRS WTFR (callstack_init p)).
- intros [ms' [EXEC' CSI]].
- red. exists fptr; exists f; exists rs; exists ms'. tauto.
-Qed.
diff --git a/backend/Machconcr.v b/backend/Machconcr.v
new file mode 100644
index 0000000000000000000000000000000000000000..fe9a7d90658026412aa902cc2eb5b82f90e00aa0
--- /dev/null
+++ b/backend/Machconcr.v
@@ -0,0 +1,250 @@
+(** The Mach intermediate language: concrete semantics. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Integers.
+Require Import Values.
+Require Import Mem.
+Require Import Events.
+Require Import Globalenvs.
+Require Import Smallstep.
+Require Import Op.
+Require Import Locations.
+Require Conventions.
+Require Import Mach.
+Require PPCgenretaddr.
+
+(** In the concrete semantics for Mach, the three stack-related Mach
+ instructions are interpreted as memory accesses relative to the
+ stack pointer. More precisely:
+- [Mgetstack ofs ty r] is a memory load at offset [ofs * 4] relative
+ to the stack pointer.
+- [Msetstack r ofs ty] is a memory store at offset [ofs * 4] relative
+ to the stack pointer.
+- [Mgetparam ofs ty r] is a memory load at offset [ofs * 4]
+ relative to the pointer found at offset 0 from the stack pointer.
+ The semantics maintain a linked structure of activation records,
+ with the current record containing a pointer to the record of the
+ caller function at offset 0.
+
+In addition to this linking of activation records, the concrete
+semantics also make provisions for storing a return address
+at offset 12 from the stack pointer. This stack location will
+be used by the PPC code generated by [PPCgen] to save the return
+address into the caller at the beginning of a function, then restore
+it and jump to it at the end of a function. The Mach concrete
+semantics does not attach any particular meaning to the pointer
+stored in this reserved location, but makes sure that it is preserved
+during execution of a function. The [return_address_offset] predicate
+from module [PPCgenretaddr] is used to guess the value of the return
+address that the PPC code generated later will store in the
+reserved location.
+*)
+
+Definition chunk_of_type (ty: typ) :=
+ match ty with Tint => Mint32 | Tfloat => Mfloat64 end.
+
+Definition load_stack (m: mem) (sp: val) (ty: typ) (ofs: int) :=
+ Mem.loadv (chunk_of_type ty) m (Val.add sp (Vint ofs)).
+
+Definition store_stack (m: mem) (sp: val) (ty: typ) (ofs: int) (v: val) :=
+ Mem.storev (chunk_of_type ty) m (Val.add sp (Vint ofs)) v.
+
+(** Extract the values of the arguments of an external call. *)
+
+Inductive extcall_arg: regset -> mem -> val -> loc -> val -> Prop :=
+ | extcall_arg_reg: forall rs m sp r,
+ extcall_arg rs m sp (R r) (rs r)
+ | extcall_arg_stack: forall rs m sp ofs ty v,
+ load_stack m sp ty (Int.repr (4 * ofs)) = Some v ->
+ extcall_arg rs m sp (S (Outgoing ofs ty)) v.
+
+Inductive extcall_args: regset -> mem -> val -> list loc -> list val -> Prop :=
+ | extcall_args_nil: forall rs m sp,
+ extcall_args rs m sp nil nil
+ | extcall_args_cons: forall rs m sp l1 ll v1 vl,
+ extcall_arg rs m sp l1 v1 -> extcall_args rs m sp ll vl ->
+ extcall_args rs m sp (l1 :: ll) (v1 :: vl).
+
+Definition extcall_arguments
+ (rs: regset) (m: mem) (sp: val) (sg: signature) (args: list val) : Prop :=
+ extcall_args rs m sp (Conventions.loc_arguments sg) args.
+
+(** The components of an execution state are:
+
+- [State cs f sp c rs m]: [f] is the block reference corresponding
+ to the function currently executing. [sp] is the stack pointer.
+ [c] is the list of instructions that remain to be executed.
+ [rs] assigns values to registers. [m] is the memory state.
+- [Callstate cs f rs m]: [f] is the block reference corresponding
+ to the function being called. [rs] is the current values of registers,
+ and [m] the current memory state.
+- [Returnstate cs rs m]: [rs] is the current values of registers,
+ and [m] the current memory state.
+
+[cs] is a list of stack frames [Stackframe f sp retaddr c],
+where [f] is the block reference for the calling function,
+[c] the code within this function that follows the call instruction,
+[sp] its stack pointer, and [retaddr] the return address predicted
+by [PPCgenretaddr.return_address_offset].
+*)
+
+Inductive stackframe: Set :=
+ | Stackframe:
+ forall (f: block) (sp retaddr: val) (c: code),
+ stackframe.
+
+Inductive state: Set :=
+ | State:
+ forall (stack: list stackframe) (f: block) (sp: val)
+ (c: code) (rs: regset) (m: mem),
+ state
+ | Callstate:
+ forall (stack: list stackframe) (f: block) (rs: regset) (m: mem),
+ state
+ | Returnstate:
+ forall (stack: list stackframe) (rs: regset) (m: mem),
+ state.
+
+Definition parent_sp (s: list stackframe) : val :=
+ match s with
+ | nil => Vptr Mem.nullptr Int.zero
+ | Stackframe f sp ra c :: s' => sp
+ end.
+
+Definition parent_ra (s: list stackframe) : val :=
+ match s with
+ | nil => Vzero
+ | Stackframe f sp ra c :: s' => ra
+ end.
+
+Section RELSEM.
+
+Variable ge: genv.
+
+Inductive step: state -> trace -> state -> Prop :=
+ | exec_Mlabel:
+ forall s f sp lbl c rs m,
+ step (State s f sp (Mlabel lbl :: c) rs m)
+ E0 (State s f sp c rs m)
+ | exec_Mgetstack:
+ forall s f sp ofs ty dst c rs m v,
+ load_stack m sp ty ofs = Some v ->
+ step (State s f sp (Mgetstack ofs ty dst :: c) rs m)
+ E0 (State s f sp c (rs#dst <- v) m)
+ | exec_Msetstack:
+ forall s f sp src ofs ty c rs m m',
+ store_stack m sp ty ofs (rs src) = Some m' ->
+ step (State s f sp (Msetstack src ofs ty :: c) rs m)
+ E0 (State s f sp c rs m')
+ | exec_Mgetparam:
+ forall s f sp parent ofs ty dst c rs m v,
+ load_stack m sp Tint (Int.repr 0) = Some parent ->
+ load_stack m parent ty ofs = Some v ->
+ step (State s f sp (Mgetparam ofs ty dst :: c) rs m)
+ E0 (State s f sp c (rs#dst <- v) m)
+ | exec_Mop:
+ forall s f sp op args res c rs m v,
+ eval_operation ge sp op rs##args m = Some v ->
+ step (State s f sp (Mop op args res :: c) rs m)
+ E0 (State s f sp c (rs#res <- v) m)
+ | exec_Mload:
+ forall s f sp chunk addr args dst c rs m a v,
+ eval_addressing ge sp addr rs##args = Some a ->
+ Mem.loadv chunk m a = Some v ->
+ step (State s f sp (Mload chunk addr args dst :: c) rs m)
+ E0 (State s f sp c (rs#dst <- v) m)
+ | exec_Mstore:
+ forall s f sp chunk addr args src c rs m m' a,
+ eval_addressing ge sp addr rs##args = Some a ->
+ Mem.storev chunk m a (rs src) = Some m' ->
+ step (State s f sp (Mstore chunk addr args src :: c) rs m)
+ E0 (State s f sp c rs m')
+ | exec_Mcall:
+ forall s fb sp sig ros c rs m f f' ra,
+ find_function_ptr ge ros rs = Some f' ->
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ PPCgenretaddr.return_address_offset f c ra ->
+ step (State s fb sp (Mcall sig ros :: c) rs m)
+ E0 (Callstate (Stackframe fb sp (Vptr fb ra) c :: s)
+ f' rs m)
+ | exec_Mtailcall:
+ forall s fb stk soff sig ros c rs m f',
+ find_function_ptr ge ros rs = Some f' ->
+ load_stack m (Vptr stk soff) Tint (Int.repr 0) = Some (parent_sp s) ->
+ load_stack m (Vptr stk soff) Tint (Int.repr 12) = Some (parent_ra s) ->
+ step (State s fb (Vptr stk soff) (Mtailcall sig ros :: c) rs m)
+ E0 (Callstate s f' rs (Mem.free m stk))
+ | exec_Malloc:
+ forall s f sp c rs m sz m' blk,
+ rs (Conventions.loc_alloc_argument) = Vint sz ->
+ Mem.alloc m 0 (Int.signed sz) = (m', blk) ->
+ step (State s f sp (Malloc :: c) rs m)
+ E0 (State s f sp c
+ (rs#Conventions.loc_alloc_result <- (Vptr blk Int.zero))
+ m')
+ | exec_Mgoto:
+ forall s fb f sp lbl c rs m c',
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ find_label lbl f.(fn_code) = Some c' ->
+ step (State s fb sp (Mgoto lbl :: c) rs m)
+ E0 (State s fb sp c' rs m)
+ | exec_Mcond_true:
+ forall s fb f sp cond args lbl c rs m c',
+ eval_condition cond rs##args m = Some true ->
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ find_label lbl f.(fn_code) = Some c' ->
+ step (State s fb sp (Mcond cond args lbl :: c) rs m)
+ E0 (State s fb sp c' rs m)
+ | exec_Mcond_false:
+ forall s f sp cond args lbl c rs m,
+ eval_condition cond rs##args m = Some false ->
+ step (State s f sp (Mcond cond args lbl :: c) rs m)
+ E0 (State s f sp c rs m)
+ | exec_Mreturn:
+ forall s f stk soff c rs m,
+ load_stack m (Vptr stk soff) Tint (Int.repr 0) = Some (parent_sp s) ->
+ load_stack m (Vptr stk soff) Tint (Int.repr 12) = Some (parent_ra s) ->
+ step (State s f (Vptr stk soff) (Mreturn :: c) rs m)
+ E0 (Returnstate s rs (Mem.free m stk))
+ | exec_function_internal:
+ forall s fb rs m f m1 m2 m3 stk,
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ Mem.alloc m (- f.(fn_framesize))
+ (align_16_top (- f.(fn_framesize)) f.(fn_stacksize))
+ = (m1, stk) ->
+ let sp := Vptr stk (Int.repr (-f.(fn_framesize))) in
+ store_stack m1 sp Tint (Int.repr 0) (parent_sp s) = Some m2 ->
+ store_stack m2 sp Tint (Int.repr 12) (parent_ra s) = Some m3 ->
+ step (Callstate s fb rs m)
+ E0 (State s fb sp f.(fn_code) rs m3)
+ | exec_function_external:
+ forall s fb rs m t rs' ef args res,
+ Genv.find_funct_ptr ge fb = Some (External ef) ->
+ event_match ef args t res ->
+ extcall_arguments rs m (parent_sp s) ef.(ef_sig) args ->
+ rs' = (rs#(Conventions.loc_result ef.(ef_sig)) <- res) ->
+ step (Callstate s fb rs m)
+ t (Returnstate s rs' m)
+ | exec_return:
+ forall s f sp ra c rs m,
+ step (Returnstate (Stackframe f sp ra c :: s) rs m)
+ E0 (State s f sp c rs m).
+
+End RELSEM.
+
+Inductive initial_state (p: program): state -> Prop :=
+ | initial_state_intro: forall fb,
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ Genv.find_symbol ge p.(prog_main) = Some fb ->
+ initial_state p (Callstate nil fb (Regmap.init Vundef) m0).
+
+Inductive final_state: state -> int -> Prop :=
+ | final_state_intro: forall rs m r,
+ rs R3 = Vint r ->
+ final_state (Returnstate nil rs m) r.
+
+Definition exec_program (p: program) (beh: program_behavior) : Prop :=
+ program_behaves step (initial_state p) final_state (Genv.globalenv p) beh.
diff --git a/backend/Machtyping.v b/backend/Machtyping.v
index ad3ee8860322b07ff20e86f256e6bb3852fb53f9..28037cec5ea6d4b6bf3b97a06f9e40908ae74b7c 100644
--- a/backend/Machtyping.v
+++ b/backend/Machtyping.v
@@ -26,7 +26,7 @@ Inductive wt_instr : instruction -> Prop :=
wt_instr (Mgetstack ofs ty r)
| wt_Msetstack:
forall ofs ty r,
- mreg_type r = ty -> 24 <= Int.signed ofs ->
+ mreg_type r = ty ->
wt_instr (Msetstack r ofs ty)
| wt_Mgetparam:
forall ofs ty r,
@@ -36,12 +36,9 @@ Inductive wt_instr : instruction -> Prop :=
forall r1 r,
mreg_type r1 = mreg_type r ->
wt_instr (Mop Omove (r1 :: nil) r)
- | wt_Mopundef:
- forall r,
- wt_instr (Mop Oundef nil r)
| wt_Mop:
forall op args res,
- op <> Omove -> op <> Oundef ->
+ op <> Omove ->
(List.map mreg_type args, mreg_type res) = type_of_operation op ->
wt_instr (Mop op args res)
| wt_Mload:
@@ -58,6 +55,11 @@ Inductive wt_instr : instruction -> Prop :=
forall sig ros,
match ros with inl r => mreg_type r = Tint | inr s => True end ->
wt_instr (Mcall sig ros)
+ | wt_Mtailcall:
+ forall sig ros,
+ Conventions.tailcall_possible sig ->
+ match ros with inl r => mreg_type r = Tint | inr s => True end ->
+ wt_instr (Mtailcall sig ros)
| wt_Malloc:
wt_instr Malloc
| wt_Mgoto:
@@ -95,27 +97,20 @@ Definition wt_program (p: program) : Prop :=
Require Import Machabstr.
-(** We show a weak type soundness result for the alternate semantics
+(** We show a weak type soundness result for the abstract semantics
of Mach: for a well-typed Mach program, if a transition is taken
from a state where registers hold values of their static types,
registers in the final state hold values of their static types
as well. This is a subject reduction theorem for our type system.
It is used in the proof of implication from the abstract Mach
- semantics to the concrete Mach semantics (file [Machabstr2mach]).
+ semantics to the concrete Mach semantics (file [Machabstr2concr]).
*)
Definition wt_regset (rs: regset) : Prop :=
forall r, Val.has_type (rs r) (mreg_type r).
-Definition wt_content (c: content) : Prop :=
- match c with
- | Datum32 v => Val.has_type v Tint
- | Datum64 v => Val.has_type v Tfloat
- | _ => True
- end.
-
Definition wt_frame (fr: frame) : Prop :=
- forall ofs, wt_content (fr.(contents) ofs).
+ forall ty ofs, Val.has_type (fr.(fr_contents) ty ofs) ty.
Lemma wt_setreg:
forall (rs: regset) (r: mreg) (v: val),
@@ -134,17 +129,8 @@ Lemma wt_get_slot:
wt_frame fr ->
Val.has_type v ty.
Proof.
- induction 1; intro. subst v.
- set (pos := low fr + ofs).
- case ty; simpl.
- unfold getN. case (check_cont 3 (pos + 1) (contents fr)).
- generalize (H2 pos). unfold wt_content.
- destruct (contents fr pos); simpl; tauto.
- simpl; auto.
- unfold getN. case (check_cont 7 (pos + 1) (contents fr)).
- generalize (H2 pos). unfold wt_content.
- destruct (contents fr pos); simpl; tauto.
- simpl; auto.
+ induction 1; intros.
+ subst v. apply H2.
Qed.
Lemma wt_set_slot:
@@ -154,43 +140,37 @@ Lemma wt_set_slot:
Val.has_type v ty ->
wt_frame fr'.
Proof.
- intros. induction H.
- set (i := low fr + ofs).
- red; intro j; simpl.
- assert (forall n ofs c,
- let c' := set_cont n ofs c in
- forall k, c' k = c k \/ c' k = Cont).
- induction n; simpl; intros.
- left; auto.
- unfold update. case (zeq k ofs0); intro.
- right; auto.
- apply IHn.
- destruct ty; simpl; unfold store_contents; unfold setN;
- unfold update; case (zeq j i); intro.
- red. assumption.
- elim (H 3%nat (i + 1) (contents fr) j); intro; rewrite H2.
- apply H0. red; auto.
- red. assumption.
- elim (H 7%nat (i + 1) (contents fr) j); intro; rewrite H2.
- apply H0. red; auto.
+ intros. induction H. subst fr'; red; intros; simpl.
+ destruct (zeq (fr_low fr + ofs) ofs0).
+ destruct (typ_eq ty ty0). congruence. exact I.
+ destruct (zle (ofs0 + AST.typesize ty0) (fr_low fr + ofs)).
+ apply H0.
+ destruct (zle (fr_low fr + ofs + AST.typesize ty) ofs0).
+ apply H0.
+ exact I.
+Qed.
+
+Lemma wt_empty_frame:
+ wt_frame empty_frame.
+Proof.
+ intros; red; intros; exact I.
Qed.
Lemma wt_init_frame:
forall f,
wt_frame (init_frame f).
Proof.
- intros. unfold init_frame.
- red; intros. simpl. exact I.
+ intros; red; intros; exact I.
Qed.
-Lemma incl_find_label:
- forall lbl c c', find_label lbl c = Some c' -> incl c' c.
+Lemma is_tail_find_label:
+ forall lbl c c', find_label lbl c = Some c' -> is_tail c' c.
Proof.
induction c; simpl.
intros; discriminate.
case (is_label lbl a); intros.
- injection H; intro; subst c'; apply incl_tl; apply incl_refl.
- apply incl_tl; auto.
+ injection H; intro; subst c'. constructor. constructor.
+ constructor; auto.
Qed.
Lemma wt_event_match:
@@ -203,193 +183,115 @@ Qed.
Section SUBJECT_REDUCTION.
+Inductive wt_stackframe: stackframe -> Prop :=
+ | wt_stackframe_intro: forall f sp c fr,
+ wt_function f ->
+ Val.has_type sp Tint ->
+ is_tail c f.(fn_code) ->
+ wt_frame fr ->
+ wt_stackframe (Stackframe f sp c fr).
+
+Inductive wt_state: state -> Prop :=
+ | wt_state_intro: forall stk f sp c rs fr m
+ (STK: forall s, In s stk -> wt_stackframe s)
+ (WTF: wt_function f)
+ (WTSP: Val.has_type sp Tint)
+ (TAIL: is_tail c f.(fn_code))
+ (WTRS: wt_regset rs)
+ (WTFR: wt_frame fr),
+ wt_state (State stk f sp c rs fr m)
+ | wt_state_call: forall stk f rs m,
+ (forall s, In s stk -> wt_stackframe s) ->
+ wt_fundef f ->
+ wt_regset rs ->
+ wt_state (Callstate stk f rs m)
+ | wt_state_return: forall stk rs m,
+ (forall s, In s stk -> wt_stackframe s) ->
+ wt_regset rs ->
+ wt_state (Returnstate stk rs m).
+
Variable p: program.
Hypothesis wt_p: wt_program p.
Let ge := Genv.globalenv p.
-Definition exec_instr_prop
- (f: function) (sp: val) (parent: frame)
- (c1: code) (rs1: regset) (fr1: frame) (m1: mem) (t: trace)
- (c2: code) (rs2: regset) (fr2: frame) (m2: mem) :=
- forall (WTF: wt_function f)
- (INCL: incl c1 f.(fn_code))
- (WTRS: wt_regset rs1)
- (WTFR: wt_frame fr1)
- (WTPA: wt_frame parent),
- incl c2 f.(fn_code) /\ wt_regset rs2 /\ wt_frame fr2.
-Definition exec_function_body_prop
- (f: function) (parent: frame) (link ra: val)
- (rs1: regset) (m1: mem) (t: trace) (rs2: regset) (m2: mem) :=
- forall (WTF: wt_function f)
- (WTRS: wt_regset rs1)
- (WTPA: wt_frame parent)
- (WTLINK: Val.has_type link Tint)
- (WTRA: Val.has_type ra Tint),
- wt_regset rs2.
-Definition exec_function_prop
- (f: fundef) (parent: frame)
- (rs1: regset) (m1: mem) (t: trace) (rs2: regset) (m2: mem) :=
- forall (WTF: wt_fundef f)
- (WTRS: wt_regset rs1)
- (WTPA: wt_frame parent),
- wt_regset rs2.
-
Lemma subject_reduction:
- (forall f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2,
- exec_instr ge f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2 ->
- exec_instr_prop f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2)
-/\ (forall f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2,
- exec_instrs ge f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2 ->
- exec_instr_prop f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2)
-/\ (forall f parent link ra rs1 m1 t rs2 m2,
- exec_function_body ge f parent link ra rs1 m1 t rs2 m2 ->
- exec_function_body_prop f parent link ra rs1 m1 t rs2 m2)
-/\ (forall f parent rs1 m1 t rs2 m2,
- exec_function ge f parent rs1 m1 t rs2 m2 ->
- exec_function_prop f parent rs1 m1 t rs2 m2).
+ forall s1 t s2, step ge s1 t s2 ->
+ forall (WTS: wt_state s1), wt_state s2.
Proof.
- apply exec_mutual_induction; red; intros;
- try (generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))); intro;
- intuition eauto with coqlib).
+ induction 1; intros; inv WTS;
+ try (generalize (wt_function_instrs _ WTF _ (is_tail_in TAIL)); intro;
+ eapply wt_state_intro; eauto with coqlib).
apply wt_setreg; auto.
inversion H0. rewrite H2. apply wt_get_slot with fr (Int.signed ofs); auto.
inversion H0. eapply wt_set_slot; eauto.
- rewrite <- H3. apply WTRS.
+ rewrite <- H2. apply WTRS.
+ assert (wt_frame (parent_frame s)).
+ destruct s; simpl. apply wt_empty_frame.
+ generalize (STK s (in_eq _ _)); intro. inv H1. auto.
inversion H0. apply wt_setreg; auto.
- rewrite H2. apply wt_get_slot with parent (Int.signed ofs); auto.
+ rewrite H3. apply wt_get_slot with (parent_frame s) (Int.signed ofs); auto.
- apply wt_setreg; auto. inversion H0.
- simpl. subst args; subst op. simpl in H.
+ apply wt_setreg; auto. inv H0.
+ simpl in H.
rewrite <- H2. replace v with (rs r1). apply WTRS. congruence.
- subst args; subst op. simpl in H.
- replace v with Vundef. simpl; auto. congruence.
replace (mreg_type res) with (snd (type_of_operation op)).
- apply type_of_operation_sound with fundef ge rs##args sp; auto.
- rewrite <- H6; reflexivity.
+ apply type_of_operation_sound with fundef ge rs##args sp m; auto.
+ rewrite <- H5; reflexivity.
apply wt_setreg; auto. inversion H1. rewrite H7.
eapply type_of_chunk_correct; eauto.
- apply H1; auto.
- destruct ros; simpl in H.
- apply (Genv.find_funct_prop wt_fundef wt_p H).
- destruct (Genv.find_symbol ge i).
- apply (Genv.find_funct_ptr_prop wt_fundef wt_p H).
- discriminate.
+ assert (WTFD: wt_fundef f').
+ destruct ros; simpl in H.
+ apply (Genv.find_funct_prop wt_fundef wt_p H).
+ destruct (Genv.find_symbol ge i); try discriminate.
+ apply (Genv.find_funct_ptr_prop wt_fundef wt_p H).
+ econstructor; eauto.
+ intros. elim H0; intro. subst s0. econstructor; eauto with coqlib.
+ auto.
+
+ assert (WTFD: wt_fundef f').
+ destruct ros; simpl in H.
+ apply (Genv.find_funct_prop wt_fundef wt_p H).
+ destruct (Genv.find_symbol ge i); try discriminate.
+ apply (Genv.find_funct_ptr_prop wt_fundef wt_p H).
+ econstructor; eauto.
apply wt_setreg; auto. exact I.
- apply incl_find_label with lbl; auto.
- apply incl_find_label with lbl; auto.
+ apply is_tail_find_label with lbl; congruence.
+ apply is_tail_find_label with lbl; congruence.
- tauto.
- apply H0; auto.
- generalize (H0 WTF INCL WTRS WTFR WTPA). intros [A [B C]].
- apply H2; auto.
+ econstructor; eauto.
- assert (WTFR2: wt_frame fr2).
- eapply wt_set_slot; eauto.
- eapply wt_set_slot; eauto.
- apply wt_init_frame.
- generalize (H3 WTF (incl_refl _) WTRS WTFR2 WTPA).
- tauto.
+ econstructor; eauto with coqlib. inv H5; auto. exact I.
+ apply wt_init_frame.
- apply (H0 Vzero Vzero). exact I. exact I.
- inversion WTF; auto. auto. auto.
- exact I. exact I.
-
- rewrite H1. apply wt_setreg; auto.
+ econstructor; eauto. apply wt_setreg; auto.
generalize (wt_event_match _ _ _ _ H).
unfold proj_sig_res, Conventions.loc_result.
destruct (sig_res (ef_sig ef)).
- destruct t; simpl; auto.
+ destruct t0; simpl; auto.
simpl; auto.
-Qed.
-
-Lemma subject_reduction_instr:
- forall f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2,
- exec_instr ge f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2 ->
- exec_instr_prop f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2.
-Proof (proj1 subject_reduction).
-
-Lemma subject_reduction_instrs:
- forall f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2,
- exec_instrs ge f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2 ->
- exec_instr_prop f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2.
-Proof (proj1 (proj2 subject_reduction)).
-Lemma subject_reduction_function:
- forall f parent rs1 m1 t rs2 m2,
- exec_function ge f parent rs1 m1 t rs2 m2 ->
- exec_function_prop f parent rs1 m1 t rs2 m2.
-Proof (proj2 (proj2 (proj2 subject_reduction))).
-
-End SUBJECT_REDUCTION.
-
-(** * Preservation of the reserved frame slots during execution *)
-
-(** We now show another result useful for the proof of implication
- between the two Mach semantics: well-typed functions do not
- change the values of the back link and return address fields
- of the frame slot (at offsets 0 and 12) during their execution.
- Actually, we show that the whole reserved part of the frame
- (between offsets 0 and 24) does not change. *)
-
-Definition link_invariant (fr1 fr2: frame) : Prop :=
- forall pos v,
- 0 <= pos < 20 ->
- get_slot fr1 Tint pos v -> get_slot fr2 Tint pos v.
-
-Remark link_invariant_refl:
- forall fr, link_invariant fr fr.
-Proof.
- intros; red; auto.
+ generalize (H1 _ (in_eq _ _)); intro. inv H.
+ econstructor; eauto.
+ eauto with coqlib.
Qed.
-
-Lemma set_slot_link_invariant:
- forall fr ty ofs v fr',
- set_slot fr ty ofs v fr' ->
- 24 <= ofs ->
- link_invariant fr fr'.
-Proof.
- induction 1. intros; red; intros.
- inversion H1. constructor. auto. exact H3.
- simpl contents. simpl low. symmetry. rewrite H4.
- apply load_store_contents_other. simpl. simpl in H3.
- omega.
-Qed.
-
-Lemma exec_instr_link_invariant:
- forall ge f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2,
- exec_instr ge f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2 ->
- wt_function f ->
- incl c1 f.(fn_code) ->
- incl c2 f.(fn_code) /\ link_invariant fr1 fr2.
-Proof.
- induction 1; intros;
- (split; [eauto with coqlib | try (apply link_invariant_refl)]).
- eapply set_slot_link_invariant; eauto.
- generalize (wt_function_instrs _ H0 _ (H1 _ (in_eq _ _))); intro.
- inversion H2. auto.
- eapply incl_find_label; eauto.
- eapply incl_find_label; eauto.
-Qed.
-
-Lemma exec_instrs_link_invariant:
- forall ge f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2,
- exec_instrs ge f sp parent c1 rs1 fr1 m1 t c2 rs2 fr2 m2 ->
- wt_function f ->
- incl c1 f.(fn_code) ->
- incl c2 f.(fn_code) /\ link_invariant fr1 fr2.
+(*
+Lemma subject_reduction_2:
+ forall s1 t s2, step ge s1 t s2 ->
+ forall (WTS: wt_state s1), wt_state s2.
Proof.
induction 1; intros.
- split. auto. apply link_invariant_refl.
- eapply exec_instr_link_invariant; eauto.
- generalize (IHexec_instrs1 H2 H3); intros [A B].
- generalize (IHexec_instrs2 H2 A); intros [C D].
- split. auto. red; auto.
+ auto.
+ eapply subject_reduction; eauto.
+ auto.
Qed.
+*)
+
+End SUBJECT_REDUCTION.
diff --git a/backend/Op.v b/backend/Op.v
index efd0d9ceb5b1fd44f7c9d4df2de442b688ff22a8..698b433c044c5c87ef433aa8379d3189a38b0cad 100644
--- a/backend/Op.v
+++ b/backend/Op.v
@@ -1,5 +1,5 @@
(** Operators and addressing modes. The abstract syntax and dynamic
- semantics for the Cminor, RTL, LTL and Mach languages depend on the
+ semantics for the CminorSel, RTL, LTL and Mach languages depend on the
following types, defined in this library:
- [condition]: boolean conditions for conditional branches;
- [operation]: arithmetic and logical operations;
@@ -9,7 +9,7 @@
processor can compute in one instruction. In other terms, these
types reflect the state of the program after instruction selection.
For a processor-independent set of operations, see the abstract
- syntax and dynamic semantics of the Csharpminor input language.
+ syntax and dynamic semantics of the Cminor language.
*)
Require Import Coqlib.
@@ -43,7 +43,6 @@ Inductive operation : Set :=
| Ofloatconst: float -> operation (**r [rd] is set to the given float constant *)
| Oaddrsymbol: ident -> int -> operation (**r [rd] is set to the the address of the symbol plus the offset *)
| Oaddrstack: int -> operation (**r [rd] is set to the stack pointer plus the given offset *)
- | Oundef: operation (**r set [rd] to undefined value *)
(*c Integer arithmetic: *)
| Ocast8signed: operation (**r [rd] is 8-bit sign extension of [r1] *)
| Ocast8unsigned: operation (**r [rd] is 8-bit zero extension of [r1] *)
@@ -110,32 +109,28 @@ Definition eval_compare_null (c: comparison) (n: int) : option bool :=
then match c with Ceq => Some false | Cne => Some true | _ => None end
else None.
-Definition eval_condition (cond: condition) (vl: list val) : option bool :=
+Definition eval_condition (cond: condition) (vl: list val) (m: mem):
+ option bool :=
match cond, vl with
| Ccomp c, Vint n1 :: Vint n2 :: nil =>
Some (Int.cmp c n1 n2)
| Ccomp c, Vptr b1 n1 :: Vptr b2 n2 :: nil =>
- if eq_block b1 b2 then Some (Int.cmp c n1 n2) else None
+ if valid_pointer m b1 (Int.signed n1)
+ && valid_pointer m b2 (Int.signed n2) then
+ if eq_block b1 b2 then Some (Int.cmp c n1 n2) else None
+ else None
| Ccomp c, Vptr b1 n1 :: Vint n2 :: nil =>
eval_compare_null c n2
| Ccomp c, Vint n1 :: Vptr b2 n2 :: nil =>
eval_compare_null c n1
| Ccompu c, Vint n1 :: Vint n2 :: nil =>
Some (Int.cmpu c n1 n2)
- | Ccompu c, Vptr b1 n1 :: Vptr b2 n2 :: nil =>
- if eq_block b1 b2 then Some (Int.cmpu c n1 n2) else None
- | Ccompu c, Vptr b1 n1 :: Vint n2 :: nil =>
- eval_compare_null c n2
- | Ccompu c, Vint n1 :: Vptr b2 n2 :: nil =>
- eval_compare_null c n1
| Ccompimm c n, Vint n1 :: nil =>
Some (Int.cmp c n1 n)
| Ccompimm c n, Vptr b1 n1 :: nil =>
eval_compare_null c n
| Ccompuimm c n, Vint n1 :: nil =>
Some (Int.cmpu c n1 n)
- | Ccompuimm c n, Vptr b1 n1 :: nil =>
- eval_compare_null c n
| Ccompf c, Vfloat f1 :: Vfloat f2 :: nil =>
Some (Float.cmp c f1 f2)
| Cnotcompf c, Vfloat f1 :: Vfloat f2 :: nil =>
@@ -156,7 +151,7 @@ Definition offset_sp (sp: val) (delta: int) : option val :=
Definition eval_operation
(F: Set) (genv: Genv.t F) (sp: val)
- (op: operation) (vl: list val) : option val :=
+ (op: operation) (vl: list val) (m: mem): option val :=
match op, vl with
| Omove, v1::nil => Some v1
| Ointconst n, nil => Some (Vint n)
@@ -167,7 +162,6 @@ Definition eval_operation
| Some b => Some (Vptr b ofs)
end
| Oaddrstack ofs, nil => offset_sp sp ofs
- | Oundef, nil => Some Vundef
| Ocast8signed, v1 :: nil => Some (Val.cast8signed v1)
| Ocast8unsigned, v1 :: nil => Some (Val.cast8unsigned v1)
| Ocast16signed, v1 :: nil => Some (Val.cast16signed v1)
@@ -228,7 +222,7 @@ Definition eval_operation
| Ofloatofintu, Vint n1 :: nil =>
Some (Vfloat (Float.floatofintu n1))
| Ocmp c, _ =>
- match eval_condition c vl with
+ match eval_condition c vl m with
| None => None
| Some false => Some Vfalse
| Some true => Some Vtrue
@@ -297,26 +291,23 @@ Proof.
Qed.
Lemma eval_negate_condition:
- forall (cond: condition) (vl: list val) (b: bool),
- eval_condition cond vl = Some b ->
- eval_condition (negate_condition cond) vl = Some (negb b).
+ forall (cond: condition) (vl: list val) (b: bool) (m: mem),
+ eval_condition cond vl m = Some b ->
+ eval_condition (negate_condition cond) vl m = Some (negb b).
Proof.
intros.
destruct cond; simpl in H; FuncInv; try subst b; simpl.
rewrite Int.negate_cmp. auto.
apply eval_negate_compare_null; auto.
apply eval_negate_compare_null; auto.
+ destruct (valid_pointer m b0 (Int.signed i) &&
+ valid_pointer m b1 (Int.signed i0)).
destruct (eq_block b0 b1). rewrite Int.negate_cmp. congruence.
- discriminate.
+ discriminate. discriminate.
rewrite Int.negate_cmpu. auto.
- apply eval_negate_compare_null; auto.
- apply eval_negate_compare_null; auto.
- destruct (eq_block b0 b1). rewrite Int.negate_cmpu. congruence.
- discriminate.
rewrite Int.negate_cmp. auto.
apply eval_negate_compare_null; auto.
rewrite Int.negate_cmpu. auto.
- apply eval_negate_compare_null; auto.
auto.
rewrite negb_elim. auto.
auto.
@@ -337,8 +328,8 @@ Hypothesis agree_on_symbols:
forall (s: ident), Genv.find_symbol ge2 s = Genv.find_symbol ge1 s.
Lemma eval_operation_preserved:
- forall sp op vl,
- eval_operation ge2 sp op vl = eval_operation ge1 sp op vl.
+ forall sp op vl m,
+ eval_operation ge2 sp op vl m = eval_operation ge1 sp op vl m.
Proof.
intros.
unfold eval_operation; destruct op; try rewrite agree_on_symbols;
@@ -356,6 +347,74 @@ Qed.
End GENV_TRANSF.
+(** [eval_condition] and [eval_operation] depend on a memory store
+ (to check pointer validity in pointer comparisons).
+ We show that their results are preserved by a change of
+ memory if this change preserves pointer validity.
+ In particular, this holds in case of a memory allocation
+ or a memory store. *)
+
+Lemma eval_condition_change_mem:
+ forall m m' c args b,
+ (forall b ofs, valid_pointer m b ofs = true -> valid_pointer m' b ofs = true) ->
+ eval_condition c args m = Some b -> eval_condition c args m' = Some b.
+Proof.
+ intros until b. intro INV. destruct c; simpl; auto.
+ destruct args; auto. destruct v; auto. destruct args; auto.
+ destruct v; auto. destruct args; auto.
+ caseEq (valid_pointer m b0 (Int.signed i)); intro.
+ caseEq (valid_pointer m b1 (Int.signed i0)); intro.
+ simpl. rewrite (INV _ _ H). rewrite (INV _ _ H0). auto.
+ simpl; congruence. simpl; congruence.
+Qed.
+
+Lemma eval_operation_change_mem:
+ forall (F: Set) m m' (ge: Genv.t F) sp op args v,
+ (forall b ofs, valid_pointer m b ofs = true -> valid_pointer m' b ofs = true) ->
+ eval_operation ge sp op args m = Some v -> eval_operation ge sp op args m' = Some v.
+Proof.
+ intros until v; intro INV. destruct op; simpl; auto.
+ caseEq (eval_condition c args m); intros.
+ rewrite (eval_condition_change_mem _ _ _ _ INV H). auto.
+ discriminate.
+Qed.
+
+Lemma eval_condition_alloc:
+ forall m lo hi m' b c args v,
+ Mem.alloc m lo hi = (m', b) ->
+ eval_condition c args m = Some v -> eval_condition c args m' = Some v.
+Proof.
+ intros. apply eval_condition_change_mem with m; auto.
+ intros. eapply valid_pointer_alloc; eauto.
+Qed.
+
+Lemma eval_operation_alloc:
+ forall (F: Set) m lo hi m' b (ge: Genv.t F) sp op args v,
+ Mem.alloc m lo hi = (m', b) ->
+ eval_operation ge sp op args m = Some v -> eval_operation ge sp op args m' = Some v.
+Proof.
+ intros. apply eval_operation_change_mem with m; auto.
+ intros. eapply valid_pointer_alloc; eauto.
+Qed.
+
+Lemma eval_condition_store:
+ forall chunk m b ofs v' m' c args v,
+ Mem.store chunk m b ofs v' = Some m' ->
+ eval_condition c args m = Some v -> eval_condition c args m' = Some v.
+Proof.
+ intros. apply eval_condition_change_mem with m; auto.
+ intros. eapply valid_pointer_store; eauto.
+Qed.
+
+Lemma eval_operation_store:
+ forall (F: Set) chunk m b ofs v' m' (ge: Genv.t F) sp op args v,
+ Mem.store chunk m b ofs v' = Some m' ->
+ eval_operation ge sp op args m = Some v -> eval_operation ge sp op args m' = Some v.
+Proof.
+ intros. apply eval_operation_change_mem with m; auto.
+ intros. eapply valid_pointer_store; eauto.
+Qed.
+
(** Recognition of move operations. *)
Definition is_move_operation
@@ -398,7 +457,6 @@ Definition type_of_operation (op: operation) : list typ * typ :=
| Ofloatconst _ => (nil, Tfloat)
| Oaddrsymbol _ _ => (nil, Tint)
| Oaddrstack _ => (nil, Tint)
- | Oundef => (nil, Tint) (* treated specially *)
| Ocast8signed => (Tint :: nil, Tint)
| Ocast8unsigned => (Tint :: nil, Tint)
| Ocast16signed => (Tint :: nil, Tint)
@@ -471,40 +529,40 @@ Variable A: Set.
Variable genv: Genv.t A.
Lemma type_of_operation_sound:
- forall op vl sp v,
- op <> Omove -> op <> Oundef ->
- eval_operation genv sp op vl = Some v ->
+ forall op vl sp v m,
+ op <> Omove ->
+ eval_operation genv sp op vl m = Some v ->
Val.has_type v (snd (type_of_operation op)).
Proof.
intros.
- destruct op; simpl in H1; FuncInv; try subst v; try exact I.
+ destruct op; simpl in H0; FuncInv; try subst v; try exact I.
congruence.
- destruct (Genv.find_symbol genv i); simplify_eq H1; intro; subst v; exact I.
- simpl. unfold offset_sp in H1. destruct sp; try discriminate.
- inversion H1. exact I.
+ destruct (Genv.find_symbol genv i); simplify_eq H0; intro; subst v; exact I.
+ simpl. unfold offset_sp in H0. destruct sp; try discriminate.
+ inversion H0. exact I.
destruct v0; exact I.
destruct v0; exact I.
destruct v0; exact I.
destruct v0; exact I.
- destruct (eq_block b b0). injection H1; intro; subst v; exact I.
+ destruct (eq_block b b0). injection H0; intro; subst v; exact I.
discriminate.
destruct (Int.eq i0 Int.zero). discriminate.
- injection H1; intro; subst v; exact I.
+ injection H0; intro; subst v; exact I.
destruct (Int.eq i0 Int.zero). discriminate.
- injection H1; intro; subst v; exact I.
+ injection H0; intro; subst v; exact I.
destruct (Int.ltu i0 (Int.repr 32)).
- injection H1; intro; subst v; exact I. discriminate.
+ injection H0; intro; subst v; exact I. discriminate.
destruct (Int.ltu i0 (Int.repr 32)).
- injection H1; intro; subst v; exact I. discriminate.
+ injection H0; intro; subst v; exact I. discriminate.
destruct (Int.ltu i (Int.repr 32)).
- injection H1; intro; subst v; exact I. discriminate.
+ injection H0; intro; subst v; exact I. discriminate.
destruct (Int.ltu i (Int.repr 32)).
- injection H1; intro; subst v; exact I. discriminate.
+ injection H0; intro; subst v; exact I. discriminate.
destruct (Int.ltu i0 (Int.repr 32)).
- injection H1; intro; subst v; exact I. discriminate.
+ injection H0; intro; subst v; exact I. discriminate.
destruct v0; exact I.
destruct (eval_condition c vl).
- destruct b; injection H1; intro; subst v; exact I.
+ destruct b; injection H0; intro; subst v; exact I.
discriminate.
Qed.
@@ -519,7 +577,7 @@ Proof.
intros until v. unfold Mem.loadv.
destruct addr; intros; try discriminate.
generalize (Mem.load_inv _ _ _ _ _ H0).
- intros [X [Y [Z W]]]. subst v. apply H.
+ intros [X Y]. subst v. apply H.
Qed.
End SOUNDNESS.
@@ -559,7 +617,6 @@ Definition eval_operation_total (sp: val) (op: operation) (vl: list val) : val :
| Ofloatconst n, nil => Vfloat n
| Oaddrsymbol s ofs, nil => find_symbol_offset s ofs
| Oaddrstack ofs, nil => Val.add sp (Vint ofs)
- | Oundef, nil => Vundef
| Ocast8signed, v1::nil => Val.cast8signed v1
| Ocast8unsigned, v1::nil => Val.cast8unsigned v1
| Ocast16signed, v1::nil => Val.cast16signed v1
@@ -625,23 +682,25 @@ Proof.
Qed.
Lemma eval_condition_weaken:
- forall c vl b,
- eval_condition c vl = Some b ->
+ forall c vl m b,
+ eval_condition c vl m = Some b ->
eval_condition_total c vl = Val.of_bool b.
Proof.
intros.
unfold eval_condition in H; destruct c; FuncInv;
try subst b; try reflexivity; simpl;
try (apply eval_compare_null_weaken; auto).
+ destruct (valid_pointer m b0 (Int.signed i) &&
+ valid_pointer m b1 (Int.signed i0)).
unfold eq_block in H. destruct (zeq b0 b1); congruence.
- unfold eq_block in H. destruct (zeq b0 b1); congruence.
+ discriminate.
symmetry. apply Val.notbool_negb_1.
symmetry. apply Val.notbool_negb_1.
Qed.
Lemma eval_operation_weaken:
- forall sp op vl v,
- eval_operation genv sp op vl = Some v ->
+ forall sp op vl m v,
+ eval_operation genv sp op vl m = Some v ->
eval_operation_total sp op vl = v.
Proof.
intros.
@@ -660,9 +719,9 @@ Proof.
destruct (Int.ltu i (Int.repr 32)); congruence.
destruct (Int.ltu i (Int.repr 32)); congruence.
destruct (Int.ltu i0 (Int.repr 32)); congruence.
- caseEq (eval_condition c vl); intros; rewrite H0 in H.
+ caseEq (eval_condition c vl m); intros; rewrite H0 in H.
replace v with (Val.of_bool b).
- apply eval_condition_weaken; auto.
+ eapply eval_condition_weaken; eauto.
destruct b; simpl; congruence.
discriminate.
Qed.
@@ -702,3 +761,95 @@ Proof.
Qed.
End EVAL_OP_TOTAL.
+
+(** Compatibility of the evaluation functions with the
+ ``is less defined'' relation over values and memory states. *)
+
+Section EVAL_LESSDEF.
+
+Variable F: Set.
+Variable genv: Genv.t F.
+Variables m1 m2: mem.
+Hypothesis MEM: Mem.lessdef m1 m2.
+
+Ltac InvLessdef :=
+ match goal with
+ | [ H: Val.lessdef (Vint _) _ |- _ ] =>
+ inv H; InvLessdef
+ | [ H: Val.lessdef (Vfloat _) _ |- _ ] =>
+ inv H; InvLessdef
+ | [ H: Val.lessdef (Vptr _ _) _ |- _ ] =>
+ inv H; InvLessdef
+ | [ H: Val.lessdef_list nil _ |- _ ] =>
+ inv H; InvLessdef
+ | [ H: Val.lessdef_list (_ :: _) _ |- _ ] =>
+ inv H; InvLessdef
+ | _ => idtac
+ end.
+
+Lemma eval_condition_lessdef:
+ forall cond vl1 vl2 b,
+ Val.lessdef_list vl1 vl2 ->
+ eval_condition cond vl1 m1 = Some b ->
+ eval_condition cond vl2 m2 = Some b.
+Proof.
+ intros. destruct cond; simpl in *; FuncInv; InvLessdef; auto.
+ generalize H0.
+ caseEq (valid_pointer m1 b0 (Int.signed i)); intro; simpl; try congruence.
+ caseEq (valid_pointer m1 b1 (Int.signed i0)); intro; simpl; try congruence.
+ destruct (eq_block b0 b1); try congruence.
+ intro. inv H2.
+ rewrite (Mem.valid_pointer_lessdef _ _ _ _ MEM H1).
+ rewrite (Mem.valid_pointer_lessdef _ _ _ _ MEM H).
+ auto.
+Qed.
+
+Ltac TrivialExists :=
+ match goal with
+ | [ |- exists v2, Some ?v1 = Some v2 /\ Val.lessdef ?v1 v2 ] =>
+ exists v1; split; [auto | constructor]
+ | _ => idtac
+ end.
+
+Lemma eval_operation_lessdef:
+ forall sp op vl1 vl2 v1,
+ Val.lessdef_list vl1 vl2 ->
+ eval_operation genv sp op vl1 m1 = Some v1 ->
+ exists v2, eval_operation genv sp op vl2 m2 = Some v2 /\ Val.lessdef v1 v2.
+Proof.
+ intros. destruct op; simpl in *; FuncInv; InvLessdef; TrivialExists.
+ exists v2; auto.
+ destruct (Genv.find_symbol genv i); inv H0. TrivialExists.
+ exists v1; auto.
+ exists (Val.cast8signed v2); split. auto. apply Val.cast8signed_lessdef; auto.
+ exists (Val.cast8unsigned v2); split. auto. apply Val.cast8unsigned_lessdef; auto.
+ exists (Val.cast16signed v2); split. auto. apply Val.cast16signed_lessdef; auto.
+ exists (Val.cast16unsigned v2); split. auto. apply Val.cast16unsigned_lessdef; auto.
+ destruct (eq_block b b0); inv H0. TrivialExists.
+ destruct (Int.eq i0 Int.zero); inv H0; TrivialExists.
+ destruct (Int.eq i0 Int.zero); inv H0; TrivialExists.
+ destruct (Int.ltu i0 (Int.repr 32)); inv H0; TrivialExists.
+ destruct (Int.ltu i0 (Int.repr 32)); inv H0; TrivialExists.
+ destruct (Int.ltu i (Int.repr 32)); inv H0; TrivialExists.
+ destruct (Int.ltu i (Int.repr 32)); inv H0; TrivialExists.
+ destruct (Int.ltu i0 (Int.repr 32)); inv H0; TrivialExists.
+ exists (Val.singleoffloat v2); split. auto. apply Val.singleoffloat_lessdef; auto.
+ caseEq (eval_condition c vl1 m1); intros. rewrite H1 in H0.
+ rewrite (eval_condition_lessdef c H H1).
+ destruct b; inv H0; TrivialExists.
+ rewrite H1 in H0. discriminate.
+Qed.
+
+Lemma eval_addressing_lessdef:
+ forall sp addr vl1 vl2 v1,
+ Val.lessdef_list vl1 vl2 ->
+ eval_addressing genv sp addr vl1 = Some v1 ->
+ exists v2, eval_addressing genv sp addr vl2 = Some v2 /\ Val.lessdef v1 v2.
+Proof.
+ intros. destruct addr; simpl in *; FuncInv; InvLessdef; TrivialExists.
+ destruct (Genv.find_symbol genv i); inv H0. TrivialExists.
+ destruct (Genv.find_symbol genv i); inv H0. TrivialExists.
+ exists v1; auto.
+Qed.
+
+End EVAL_LESSDEF.
diff --git a/backend/PPC.v b/backend/PPC.v
index ba645d02f8407175bd1e751aa1e1d07042c01060..66d96c29492661539f89cf08879b0f0de188cf96 100644
--- a/backend/PPC.v
+++ b/backend/PPC.v
@@ -9,6 +9,7 @@ Require Import Values.
Require Import Mem.
Require Import Events.
Require Import Globalenvs.
+Require Import Smallstep.
(** * Abstract syntax *)
@@ -97,7 +98,8 @@ Inductive instruction : Set :=
| Pbctrl: instruction (**r branch to contents of CTR and link *)
| Pbf: crbit -> label -> instruction (**r branch if false *)
| Pbl: ident -> instruction (**r branch and link *)
- | Pblr: instruction (**r branch to contents: register LR *)
+ | Pbs: ident -> instruction (**r branch to symbol *)
+ | Pblr: instruction (**r branch to contents of register LR *)
| Pbt: crbit -> label -> instruction (**r branch if true *)
| Pcmplw: ireg -> ireg -> instruction (**r unsigned integer comparison *)
| Pcmplwi: ireg -> constant -> instruction (**r same, with immediate argument *)
@@ -170,14 +172,11 @@ Inductive instruction : Set :=
| Pxor: ireg -> ireg -> ireg -> instruction (**r bitwise xor *)
| Pxori: ireg -> ireg -> constant -> instruction (**r bitwise xor with immediate *)
| Pxoris: ireg -> ireg -> constant -> instruction (**r bitwise xor with immediate high *)
- | Piundef: ireg -> instruction (**r set int reg to [Vundef] *)
- | Pfundef: freg -> instruction (**r set float reg to [Vundef] *)
| Plabel: label -> instruction. (**r define a code label *)
(** The pseudo-instructions are the following:
- [Plabel]: define a code label at the current program point
-
- [Plfi]: load a floating-point constant in a float register.
Expands to a float load [lfd] from an address in the constant data section
initialized with the floating-point constant:
@@ -190,7 +189,6 @@ lbl: .double floatcst
>>
Initialized data in the constant data section are not modeled here,
which is why we use a pseudo-instruction for this purpose.
-
- [Pfcti]: convert a float to an integer. This requires a transfer
via memory of a 32-bit integer from a float register to an int register,
which our memory model cannot express. Expands to:
@@ -200,7 +198,6 @@ lbl: .double floatcst
lwz rdst, 4(r1)
addi r1, r1, 8
>>
-
- [Pictf]: convert a signed integer to a float. This requires complicated
bit-level manipulations of IEEE floats through mixed float and integer
arithmetic over a memory word, which our memory model and axiomatization
@@ -221,7 +218,6 @@ lbl: .long 0x43300000, 0x80000000
>>
(Don't worry if you do not understand this instruction sequence: intimate
knowledge of IEEE float arithmetic is necessary.)
-
- [Piuctf]: convert an unsigned integer to a float. The expansion is close
to that [Pictf], and equally obscure.
<<
@@ -237,7 +233,6 @@ lbl: .long 0x43300000, 0x80000000
lbl: .long 0x43300000, 0x00000000
.text
>>
-
- [Pallocframe lo hi]: in the formal semantics, this pseudo-instruction
allocates a memory block with bounds [lo] and [hi], stores the value
of register [r1] (the stack pointer, by convention) at the bottom
@@ -250,7 +245,6 @@ lbl: .long 0x43300000, 0x00000000
This cannot be expressed in our memory model, which does not reflect
the fact that stack frames are adjacent and allocated/freed
following a stack discipline.
-
- [Pfreeframe]: in the formal semantics, this pseudo-instruction
reads the bottom word of the block pointed by [r1] (the stack pointer),
frees this block, and sets [r1] to the value of the bottom word.
@@ -261,27 +255,11 @@ lbl: .long 0x43300000, 0x00000000
>>
Again, our memory model cannot comprehend that this operation
frees (logically) the current stack frame.
-
- [Pallocheap]: in the formal semantics, this pseudo-instruction
allocates a heap block of size the contents of [GPR3], and leaves
a pointer to this block in [GPR3]. In the generated assembly code,
it is turned into a call to the allocation function of the run-time
system.
-
-- [Piundef] and [Pfundef]: set an integer or float register (respectively)
- to the [Vundef] value. Expand to nothing, as the PowerPC processor has
- no notion of ``undefined value''. These two pseudo-instructions are used
- to ensure that the generated PowerPC code computes exactly the same values
- as predicted by the semantics of Cminor, which explicitly set uninitialized
- local variables to the [Vundef] value. A general property of our semantics,
- not yet formally proved, is that they are monotone with respect to the
- partial ordering [Vundef <= v] over values. Consequently, if a program
- evaluates to a non-[Vundef] result [r] from an initial state that contains
- [Vundef] values, it will also evaluate to [r] if arbitrary values are put
- in the initial state instead of the [Vundef] values. This justifies
- treating [Piundef] and [Pfundef] as no-operations, leaving in the target
- register whatever value was already there instead of setting it to [Vundef].
- The formal proof of this result remains to be done, however.
*)
Definition code := list instruction.
@@ -588,6 +566,8 @@ Definition exec_instr (c: code) (i: instruction) (rs: regset) (m: mem) : outcome
end
| Pbl ident =>
OK (rs#LR <- (Val.add rs#PC Vone) #PC <- (symbol_offset ident Int.zero)) m
+ | Pbs ident =>
+ OK (rs#PC <- (symbol_offset ident Int.zero)) m
| Pblr =>
OK (rs#PC <- (rs#LR)) m
| Pbt bit lbl =>
@@ -744,10 +724,6 @@ Definition exec_instr (c: code) (i: instruction) (rs: regset) (m: mem) : outcome
OK (nextinstr (rs#rd <- (Val.xor rs#r1 (const_low cst)))) m
| Pxoris rd r1 cst =>
OK (nextinstr (rs#rd <- (Val.xor rs#r1 (const_high cst)))) m
- | Piundef rd =>
- OK (nextinstr (rs#rd <- Vundef)) m
- | Pfundef rd =>
- OK (nextinstr (rs#rd <- Vundef)) m
| Plabel lbl =>
OK (nextinstr rs) m
end.
@@ -762,7 +738,7 @@ Inductive extcall_args (rs: regset) (m: mem):
extcall_args rs m nil irl frl ofs nil
| extcall_args_int_reg: forall tyl ir1 irl frl ofs v1 vl,
v1 = rs (IR ir1) ->
- extcall_args rs m tyl irl frl (ofs + 4) vl ->
+ extcall_args rs m tyl irl frl ofs vl ->
extcall_args rs m (Tint :: tyl) (ir1 :: irl) frl ofs (v1 :: vl)
| extcall_args_int_stack: forall tyl frl ofs v1 vl,
Mem.loadv Mint32 m (Val.add (rs (IR GPR1)) (Vint (Int.repr ofs))) = Some v1 ->
@@ -770,11 +746,11 @@ Inductive extcall_args (rs: regset) (m: mem):
extcall_args rs m (Tint :: tyl) nil frl ofs (v1 :: vl)
| extcall_args_float_reg: forall tyl irl fr1 frl ofs v1 vl,
v1 = rs (FR fr1) ->
- extcall_args rs m tyl (list_drop2 irl) frl (ofs + 8) vl ->
+ extcall_args rs m tyl (list_drop2 irl) frl ofs vl ->
extcall_args rs m (Tfloat :: tyl) irl (fr1 :: frl) ofs (v1 :: vl)
| extcall_args_float_stack: forall tyl irl ofs v1 vl,
Mem.loadv Mfloat64 m (Val.add (rs (IR GPR1)) (Vint (Int.repr ofs))) = Some v1 ->
- extcall_args rs m tyl (list_drop2 irl) nil (ofs + 8) vl ->
+ extcall_args rs m tyl irl nil (ofs + 8) vl ->
extcall_args rs m (Tfloat :: tyl) irl nil ofs (v1 :: vl).
Definition extcall_arguments
@@ -783,7 +759,7 @@ Definition extcall_arguments
sg.(sig_args)
(GPR3 :: GPR4 :: GPR5 :: GPR6 :: GPR7 :: GPR8 :: GPR9 :: GPR10 :: nil)
(FPR1 :: FPR2 :: FPR3 :: FPR4 :: FPR5 :: FPR6 :: FPR7 :: FPR8 :: FPR9 :: FPR10 :: nil)
- 24 args.
+ 56 args.
Definition loc_external_result (s: signature) : preg :=
match s.(sig_res) with
@@ -794,14 +770,17 @@ Definition loc_external_result (s: signature) : preg :=
(** Execution of the instruction at [rs#PC]. *)
-Inductive exec_step: regset -> mem -> trace -> regset -> mem -> Prop :=
+Inductive state: Set :=
+ | State: regset -> mem -> state.
+
+Inductive step: state -> trace -> state -> Prop :=
| exec_step_internal:
forall b ofs c i rs m rs' m',
rs PC = Vptr b ofs ->
Genv.find_funct_ptr ge b = Some (Internal c) ->
find_instr (Int.unsigned ofs) c = Some i ->
exec_instr c i rs m = OK rs' m' ->
- exec_step rs m E0 rs' m'
+ step (State rs m) E0 (State rs' m')
| exec_step_external:
forall b ef args res rs m t rs',
rs PC = Vptr b Int.zero ->
@@ -810,33 +789,26 @@ Inductive exec_step: regset -> mem -> trace -> regset -> mem -> Prop :=
extcall_arguments rs m ef.(ef_sig) args ->
rs' = (rs#(loc_external_result ef.(ef_sig)) <- res
#PC <- (rs LR)) ->
- exec_step rs m t rs' m.
-
-(** Execution of zero, one or several instructions starting at [rs#PC]. *)
-
-Inductive exec_steps: regset -> mem -> trace -> regset -> mem -> Prop :=
- | exec_refl:
- forall rs m,
- exec_steps rs m E0 rs m
- | exec_one:
- forall rs m t rs' m',
- exec_step rs m t rs' m' ->
- exec_steps rs m t rs' m'
- | exec_trans:
- forall rs1 m1 t1 rs2 m2 t2 rs3 m3 t3,
- exec_steps rs1 m1 t1 rs2 m2 ->
- exec_steps rs2 m2 t2 rs3 m3 ->
- t3 = t1 ** t2 ->
- exec_steps rs1 m1 t3 rs3 m3.
+ step (State rs m) t (State rs' m).
End RELSEM.
-Definition exec_program (p: program) (t: trace) (r: val) : Prop :=
- let ge := Genv.globalenv p in
- let m0 := Genv.init_mem p in
- let rs0 :=
- (Pregmap.init Vundef) # PC <- (symbol_offset ge p.(prog_main) Int.zero)
- # LR <- Vzero
- # GPR1 <- (Vptr Mem.nullptr Int.zero) in
- exists rs, exists m,
- exec_steps ge rs0 m0 t rs m /\ rs#PC = Vzero /\ rs#GPR3 = r.
+Inductive initial_state (p: program): state -> Prop :=
+ | initial_state_intro:
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ let rs0 :=
+ (Pregmap.init Vundef)
+ # PC <- (symbol_offset ge p.(prog_main) Int.zero)
+ # LR <- Vzero
+ # GPR1 <- (Vptr Mem.nullptr Int.zero) in
+ initial_state p (State rs0 m0).
+
+Inductive final_state: state -> int -> Prop :=
+ | final_state_intro: forall rs m r,
+ rs#PC = Vzero ->
+ rs#GPR3 = Vint r ->
+ final_state (State rs m) r.
+
+Definition exec_program (p: program) (beh: program_behavior) : Prop :=
+ program_behaves step (initial_state p) final_state (Genv.globalenv p) beh.
diff --git a/backend/PPCgen.v b/backend/PPCgen.v
index ba8ea285dd8b42cb4248743860990a3bd533fe59..d7a83b0b5a97476bee41e0ea011c392de4fc07d7 100644
--- a/backend/PPCgen.v
+++ b/backend/PPCgen.v
@@ -2,6 +2,7 @@
Require Import Coqlib.
Require Import Maps.
+Require Import Errors.
Require Import AST.
Require Import Integers.
Require Import Floats.
@@ -268,11 +269,6 @@ Definition transl_op
Pori (ireg_of r) (ireg_of r) (Csymbol_low_unsigned s ofs) :: k
| Oaddrstack n, nil =>
addimm (ireg_of r) GPR1 n k
- | Oundef, nil =>
- match mreg_type r with
- | Tint => Piundef (ireg_of r) :: k
- | Tfloat => Pfundef (freg_of r) :: k
- end
| Ocast8signed, a1 :: nil =>
Pextsb (ireg_of r) (ireg_of a1) :: k
| Ocast8unsigned, a1 :: nil =>
@@ -474,6 +470,17 @@ Definition transl_instr (i: Mach.instruction) (k: code) :=
Pmtctr (ireg_of r) :: Pbctrl :: k
| Mcall sig (inr symb) =>
Pbl symb :: k
+ | Mtailcall sig (inl r) =>
+ Pmtctr (ireg_of r) ::
+ Plwz GPR2 (Cint (Int.repr 12)) GPR1 ::
+ Pmtlr GPR2 ::
+ Pfreeframe ::
+ Pbctr :: k
+ | Mtailcall sig (inr symb) =>
+ Plwz GPR2 (Cint (Int.repr 12)) GPR1 ::
+ Pmtlr GPR2 ::
+ Pfreeframe ::
+ Pbs symb :: k
| Malloc =>
Pallocblock :: k
| Mlabel lbl =>
@@ -510,14 +517,17 @@ Fixpoint code_size (c: code) : Z :=
| instr :: c' => code_size c' + 1
end.
-Definition transf_function (f: Mach.function) : option PPC.code :=
+Open Local Scope string_scope.
+
+Definition transf_function (f: Mach.function) : res PPC.code :=
let c := transl_function f in
if zlt Int.max_unsigned (code_size c)
- then None
- else Some c.
+ then Errors.Error (msg "code size exceeded")
+ else Errors.OK c.
-Definition transf_fundef (f: Mach.fundef) : option PPC.fundef :=
+Definition transf_fundef (f: Mach.fundef) : res PPC.fundef :=
transf_partial_fundef transf_function f.
-Definition transf_program (p: Mach.program) : option PPC.program :=
+Definition transf_program (p: Mach.program) : res PPC.program :=
transform_partial_program transf_fundef p.
+
diff --git a/backend/PPCgenproof.v b/backend/PPCgenproof.v
index f1ee9f2282466b9bf3f814e440404508dce147a4..8d6d9342b6baf36a5777f90bb470311ab83e117e 100644
--- a/backend/PPCgenproof.v
+++ b/backend/PPCgenproof.v
@@ -2,6 +2,7 @@
Require Import Coqlib.
Require Import Maps.
+Require Import Errors.
Require Import AST.
Require Import Integers.
Require Import Floats.
@@ -9,19 +10,22 @@ Require Import Values.
Require Import Mem.
Require Import Events.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Op.
Require Import Locations.
Require Import Mach.
+Require Import Machconcr.
Require Import Machtyping.
Require Import PPC.
Require Import PPCgen.
+Require Import PPCgenretaddr.
Require Import PPCgenproof1.
Section PRESERVATION.
Variable prog: Mach.program.
Variable tprog: PPC.program.
-Hypothesis TRANSF: transf_program prog = Some tprog.
+Hypothesis TRANSF: transf_program prog = Errors.OK tprog.
Let ge := Genv.globalenv prog.
Let tge := Genv.globalenv tprog.
@@ -35,16 +39,11 @@ Proof.
Qed.
Lemma functions_translated:
- forall f b,
+ forall b f,
Genv.find_funct_ptr ge b = Some f ->
- exists tf, Genv.find_funct_ptr tge b = Some tf /\ transf_fundef f = Some tf.
-Proof.
- intros.
- generalize (Genv.find_funct_ptr_transf_partial transf_fundef TRANSF H).
- case (transf_fundef f).
- intros f' [A B]. exists f'; split. assumption. auto.
- tauto.
-Qed.
+ exists tf, Genv.find_funct_ptr tge b = Some tf /\ transf_fundef f = Errors.OK tf.
+Proof
+ (Genv.find_funct_ptr_transf_partial transf_fundef TRANSF).
Lemma functions_transl:
forall f b,
@@ -54,8 +53,8 @@ Proof.
intros.
destruct (functions_translated _ _ H) as [tf [A B]].
rewrite A. generalize B. unfold transf_fundef, transf_partial_fundef, transf_function.
- case (zlt Int.max_unsigned (code_size (transl_function f))); intro.
- congruence. auto.
+ case (zlt Int.max_unsigned (code_size (transl_function f))); simpl; intro.
+ congruence. intro. inv B0. auto.
Qed.
Lemma functions_transl_no_overflow:
@@ -66,7 +65,7 @@ Proof.
intros.
destruct (functions_translated _ _ H) as [tf [A B]].
generalize B. unfold transf_fundef, transf_partial_fundef, transf_function.
- case (zlt Int.max_unsigned (code_size (transl_function f))); intro.
+ case (zlt Int.max_unsigned (code_size (transl_function f))); simpl; intro.
congruence. intro; omega.
Qed.
@@ -81,23 +80,17 @@ Proof.
left; congruence. right; eauto.
Qed.
-(** The ``code tail'' of an instruction list [c] is the list of instructions
- starting at PC [pos]. *)
-
-Fixpoint code_tail (pos: Z) (c: code) {struct c} : code :=
- match c with
- | nil => nil
- | i :: il => if zeq pos 0 then c else code_tail (pos - 1) il
- end.
-
Lemma find_instr_tail:
- forall c pos,
- find_instr pos c =
- match code_tail pos c with nil => None | i1 :: il => Some i1 end.
+ forall c1 i c2 pos,
+ code_tail pos c1 (i :: c2) ->
+ find_instr pos c1 = Some i.
Proof.
- induction c; simpl; intros.
- auto.
- case (zeq pos 0); auto.
+ induction c1; simpl; intros.
+ inv H.
+ destruct (zeq pos 0). subst pos.
+ inv H. auto. generalize (code_tail_pos _ _ _ H4). intro. omegaContradiction.
+ inv H. congruence. replace (pos0 + 1 - 1) with pos0 by omega.
+ eauto.
Qed.
Remark code_size_pos:
@@ -108,60 +101,39 @@ Qed.
Remark code_tail_bounds:
forall fn ofs i c,
- code_tail ofs fn = i :: c -> 0 <= ofs < code_size fn.
-Proof.
- induction fn; simpl.
- intros; discriminate.
- intros until c. case (zeq ofs 0); intros.
- generalize (code_size_pos fn). omega.
- generalize (IHfn _ _ _ H). omega.
-Qed.
-
-Remark code_tail_unfold:
- forall ofs i c,
- ofs >= 0 ->
- code_tail (ofs + 1) (i :: c) = code_tail ofs c.
-Proof.
- intros. simpl. case (zeq (ofs + 1) 0); intros.
- omegaContradiction.
- replace (ofs + 1 - 1) with ofs. auto. omega.
-Qed.
-
-Remark code_tail_zero:
- forall fn, code_tail 0 fn = fn.
+ code_tail ofs fn (i :: c) -> 0 <= ofs < code_size fn.
Proof.
- intros. destruct fn; simpl. auto. auto.
+ assert (forall ofs fn c, code_tail ofs fn c ->
+ forall i c', c = i :: c' -> 0 <= ofs < code_size fn).
+ induction 1; intros; simpl.
+ rewrite H. simpl. generalize (code_size_pos c'). omega.
+ generalize (IHcode_tail _ _ H0). omega.
+ eauto.
Qed.
Lemma code_tail_next:
forall fn ofs i c,
- code_tail ofs fn = i :: c ->
- code_tail (ofs + 1) fn = c.
+ code_tail ofs fn (i :: c) ->
+ code_tail (ofs + 1) fn c.
Proof.
- induction fn.
- simpl; intros; discriminate.
- intros until c. case (zeq ofs 0); intro.
- subst ofs. intros. rewrite code_tail_zero in H. injection H.
- intros. subst c. rewrite code_tail_unfold. apply code_tail_zero.
- omega.
- intro; generalize (code_tail_bounds _ _ _ _ H); intros [A B].
- assert (ofs = (ofs - 1) + 1). omega.
- rewrite H0 in H. rewrite code_tail_unfold in H.
- rewrite code_tail_unfold. rewrite H0. eauto.
- omega. omega.
+ assert (forall ofs fn c, code_tail ofs fn c ->
+ forall i c', c = i :: c' -> code_tail (ofs + 1) fn c').
+ induction 1; intros.
+ subst c. constructor. constructor.
+ constructor. eauto.
+ eauto.
Qed.
Lemma code_tail_next_int:
forall fn ofs i c,
code_size fn <= Int.max_unsigned ->
- code_tail (Int.unsigned ofs) fn = i :: c ->
- code_tail (Int.unsigned (Int.add ofs Int.one)) fn = c.
+ code_tail (Int.unsigned ofs) fn (i :: c) ->
+ code_tail (Int.unsigned (Int.add ofs Int.one)) fn c.
Proof.
- intros. rewrite Int.add_unsigned. unfold Int.one.
- repeat rewrite Int.unsigned_repr. apply code_tail_next with i; auto.
- compute; intuition congruence.
+ intros. rewrite Int.add_unsigned.
+ change (Int.unsigned Int.one) with 1.
+ rewrite Int.unsigned_repr. apply code_tail_next with i; auto.
generalize (code_tail_bounds _ _ _ _ H0). omega.
- compute; intuition congruence.
Qed.
(** [transl_code_at_pc pc fn c] holds if the code pointer [pc] points
@@ -169,12 +141,12 @@ Qed.
and [c] is the tail of the generated code at the position corresponding
to the code pointer [pc]. *)
-Inductive transl_code_at_pc: val -> Mach.function -> Mach.code -> Prop :=
+Inductive transl_code_at_pc: val -> block -> Mach.function -> Mach.code -> Prop :=
transl_code_at_pc_intro:
forall b ofs f c,
Genv.find_funct_ptr ge b = Some (Internal f) ->
- code_tail (Int.unsigned ofs) (transl_function f) = transl_code c ->
- transl_code_at_pc (Vptr b ofs) f c.
+ code_tail (Int.unsigned ofs) (transl_function f) (transl_code c) ->
+ transl_code_at_pc (Vptr b ofs) b f c.
(** The following lemmas show that straight-line executions
(predicate [exec_straight]) correspond to correct PPC executions
@@ -187,14 +159,16 @@ Lemma exec_straight_steps_1:
forall b ofs,
rs#PC = Vptr b ofs ->
Genv.find_funct_ptr tge b = Some (Internal fn) ->
- code_tail (Int.unsigned ofs) fn = c ->
- exec_steps tge rs m E0 rs' m'.
+ code_tail (Int.unsigned ofs) fn c ->
+ plus step tge (State rs m) E0 (State rs' m').
Proof.
- induction 1.
- intros. apply exec_refl.
- intros. apply exec_trans with E0 rs2 m2 E0.
- apply exec_one; econstructor; eauto.
- rewrite find_instr_tail. rewrite H5. auto.
+ induction 1; intros.
+ apply plus_one.
+ econstructor; eauto.
+ eapply find_instr_tail. eauto.
+ eapply plus_left'.
+ econstructor; eauto.
+ eapply find_instr_tail. eauto.
apply IHexec_straight with b (Int.add ofs Int.one).
auto. rewrite H0. rewrite H3. reflexivity.
auto.
@@ -209,35 +183,79 @@ Lemma exec_straight_steps_2:
forall b ofs,
rs#PC = Vptr b ofs ->
Genv.find_funct_ptr tge b = Some (Internal fn) ->
- code_tail (Int.unsigned ofs) fn = c ->
+ code_tail (Int.unsigned ofs) fn c ->
exists ofs',
rs'#PC = Vptr b ofs'
- /\ code_tail (Int.unsigned ofs') fn = c'.
+ /\ code_tail (Int.unsigned ofs') fn c'.
Proof.
induction 1; intros.
- exists ofs. split. auto. auto.
+ exists (Int.add ofs Int.one). split.
+ rewrite H0. rewrite H2. auto.
+ apply code_tail_next_int with i1; auto.
apply IHexec_straight with (Int.add ofs Int.one).
auto. rewrite H0. rewrite H3. reflexivity. auto.
apply code_tail_next_int with i; auto.
Qed.
-Lemma exec_straight_steps:
- forall f c c' rs m rs' m',
- transl_code_at_pc (rs PC) f c ->
+Lemma exec_straight_exec:
+ forall fb f c c' rs m rs' m',
+ transl_code_at_pc (rs PC) fb f c ->
+ exec_straight tge (transl_function f)
+ (transl_code c) rs m c' rs' m' ->
+ plus step tge (State rs m) E0 (State rs' m').
+Proof.
+ intros. inversion H. subst.
+ eapply exec_straight_steps_1; eauto.
+ eapply functions_transl_no_overflow; eauto.
+ eapply functions_transl; eauto.
+Qed.
+
+Lemma exec_straight_at:
+ forall fb f c c' rs m rs' m',
+ transl_code_at_pc (rs PC) fb f c ->
exec_straight tge (transl_function f)
(transl_code c) rs m (transl_code c') rs' m' ->
- exec_steps tge rs m E0 rs' m' /\ transl_code_at_pc (rs' PC) f c'.
+ transl_code_at_pc (rs' PC) fb f c'.
Proof.
- intros. inversion H.
+ intros. inversion H. subst.
generalize (functions_transl_no_overflow _ _ H2). intro.
generalize (functions_transl _ _ H2). intro.
- split. eapply exec_straight_steps_1; eauto.
generalize (exec_straight_steps_2 _ _ _ _ _ _ _
- H0 H6 _ _ (sym_equal H1) H7 H3).
+ H0 H4 _ _ (sym_equal H1) H5 H3).
intros [ofs' [PC' CT']].
rewrite PC'. constructor; auto.
Qed.
+(** Correctness of the return addresses predicted by
+ [PPCgen.return_address_offset]. *)
+
+Remark code_tail_no_bigger:
+ forall pos c1 c2, code_tail pos c1 c2 -> (length c2 <= length c1)%nat.
+Proof.
+ induction 1; simpl; omega.
+Qed.
+
+Remark code_tail_unique:
+ forall fn c pos pos',
+ code_tail pos fn c -> code_tail pos' fn c -> pos = pos'.
+Proof.
+ induction fn; intros until pos'; intros ITA CT; inv ITA; inv CT; auto.
+ generalize (code_tail_no_bigger _ _ _ H3); simpl; intro; omega.
+ generalize (code_tail_no_bigger _ _ _ H3); simpl; intro; omega.
+ f_equal. eauto.
+Qed.
+
+Lemma return_address_offset_correct:
+ forall b ofs fb f c ofs',
+ transl_code_at_pc (Vptr b ofs) fb f c ->
+ return_address_offset f c ofs' ->
+ ofs' = ofs.
+Proof.
+ intros. inv H0. inv H.
+ generalize (code_tail_unique _ _ _ _ H1 H7). intro. rewrite H.
+ apply Int.repr_unsigned.
+Qed.
+
(** The [find_label] function returns the code tail starting at the
given label. A connection with [code_tail] is then established. *)
@@ -253,7 +271,7 @@ Lemma label_pos_code_tail:
find_label lbl c = Some c' ->
exists pos',
label_pos lbl pos c = Some pos'
- /\ code_tail (pos' - pos) c = c'
+ /\ code_tail (pos' - pos) c c'
/\ pos < pos' <= pos + code_size c.
Proof.
induction c.
@@ -262,13 +280,13 @@ Proof.
case (is_label lbl a).
intro EQ; injection EQ; intro; subst c'.
exists (pos + 1). split. auto. split.
- rewrite zeq_false. replace (pos + 1 - pos - 1) with 0.
- apply code_tail_zero. omega. omega.
+ replace (pos + 1 - pos) with (0 + 1) by omega. constructor. constructor.
generalize (code_size_pos c). omega.
intros. generalize (IHc (pos + 1) c' H). intros [pos' [A [B C]]].
exists pos'. split. auto. split.
- rewrite zeq_false. replace (pos' - pos - 1) with (pos' - (pos + 1)).
- auto. omega. omega. omega.
+ replace (pos' - pos) with ((pos' - (pos + 1)) + 1) by omega.
+ constructor. auto.
+ omega.
Qed.
(** The following lemmas show that the translation from Mach to PPC
@@ -409,7 +427,6 @@ Proof.
destruct op; destruct args; try (destruct args); try (destruct args); try (destruct args);
try reflexivity; autorewrite with labels; try reflexivity.
case (mreg_type m); reflexivity.
- case (mreg_type r); reflexivity.
case (Int.eq (high_s i) Int.zero); autorewrite with labels; reflexivity.
case (Int.eq (high_s i) Int.zero); autorewrite with labels; reflexivity.
case (snd (crbit_for_cond c)); reflexivity.
@@ -453,6 +470,7 @@ Proof.
destruct m; rewrite transl_load_store_label; intros; reflexivity.
destruct m; rewrite transl_load_store_label; intros; reflexivity.
destruct s0; reflexivity.
+ destruct s0; reflexivity.
rewrite peq_false. auto. congruence.
case (snd (crbit_for_cond c)); reflexivity.
Qed.
@@ -488,7 +506,7 @@ Lemma find_label_goto_label:
Mach.find_label lbl f.(fn_code) = Some c' ->
exists rs',
goto_label (transl_function f) lbl rs m = OK rs' m
- /\ transl_code_at_pc (rs' PC) f c'
+ /\ transl_code_at_pc (rs' PC) b f c'
/\ forall r, r <> PC -> rs'#r = rs#r.
Proof.
intros.
@@ -499,13 +517,13 @@ Proof.
intros [pos' [A [B C]]].
exists (rs#PC <- (Vptr b (Int.repr pos'))).
split. unfold goto_label. rewrite A. rewrite H0. auto.
- split. rewrite Pregmap.gss. constructor. auto.
+ split. rewrite Pregmap.gss. constructor; auto.
rewrite Int.unsigned_repr. replace (pos' - 0) with pos' in B.
auto. omega.
generalize (functions_transl_no_overflow _ _ H).
omega.
intros. apply Pregmap.gso; auto.
-Qed.
+Qed.
(** * Memory properties *)
@@ -513,22 +531,39 @@ Qed.
We show that it can be synthesized as a ``load 8-bit unsigned integer''
followed by a sign extension. *)
+Remark valid_access_equiv:
+ forall chunk1 chunk2 m b ofs,
+ size_chunk chunk1 = size_chunk chunk2 ->
+ valid_access m chunk1 b ofs ->
+ valid_access m chunk2 b ofs.
+Proof.
+ intros. inv H0. rewrite H in H3. constructor; auto.
+Qed.
+
+Remark in_bounds_equiv:
+ forall chunk1 chunk2 m b ofs (A: Set) (a1 a2: A),
+ size_chunk chunk1 = size_chunk chunk2 ->
+ (if in_bounds m chunk1 b ofs then a1 else a2) =
+ (if in_bounds m chunk2 b ofs then a1 else a2).
+Proof.
+ intros. destruct (in_bounds m chunk1 b ofs).
+ rewrite in_bounds_true. auto. eapply valid_access_equiv; eauto.
+ destruct (in_bounds m chunk2 b ofs); auto.
+ elim n. eapply valid_access_equiv with (chunk1 := chunk2); eauto.
+Qed.
+
Lemma loadv_8_signed_unsigned:
forall m a,
Mem.loadv Mint8signed m a =
option_map Val.cast8signed (Mem.loadv Mint8unsigned m a).
Proof.
intros. unfold Mem.loadv. destruct a; try reflexivity.
- unfold load. case (zlt b (nextblock m)); intro.
- change (in_bounds Mint8unsigned (Int.signed i) (blocks m b))
- with (in_bounds Mint8signed (Int.signed i) (blocks m b)).
- case (in_bounds Mint8signed (Int.signed i) (blocks m b)).
- change (mem_chunk Mint8unsigned) with (mem_chunk Mint8signed).
- set (v := (load_contents (mem_chunk Mint8signed)
- (contents (blocks m b)) (Int.signed i))).
- unfold Val.load_result. destruct v; try reflexivity.
+ unfold load. rewrite (in_bounds_equiv Mint8signed Mint8unsigned).
+ destruct (in_bounds m Mint8unsigned b (Int.signed i)); auto.
+ simpl.
+ destruct (getN 0 (Int.signed i) (contents (blocks m b))); auto.
simpl. rewrite Int.cast8_signed_unsigned. auto.
- reflexivity. reflexivity.
+ auto.
Qed.
(** Similarly, we show that signed 8- and 16-bit stores can be performed
@@ -538,155 +573,201 @@ Lemma storev_8_signed_unsigned:
forall m a v,
Mem.storev Mint8signed m a v = Mem.storev Mint8unsigned m a v.
Proof.
- intros. reflexivity.
+ intros. unfold storev. destruct a; auto.
+ unfold store. rewrite (in_bounds_equiv Mint8signed Mint8unsigned).
+ auto. auto.
Qed.
Lemma storev_16_signed_unsigned:
forall m a v,
Mem.storev Mint16signed m a v = Mem.storev Mint16unsigned m a v.
Proof.
- intros. reflexivity.
+ intros. unfold storev. destruct a; auto.
+ unfold store. rewrite (in_bounds_equiv Mint16signed Mint16unsigned).
+ auto. auto.
Qed.
(** * Proof of semantic preservation *)
-(** The invariants for the inductive proof of simulation are as follows.
- The simulation diagrams are of the form:
+(** Semantic preservation is proved using simulation diagrams
+ of the following form.
<<
- c1, ms1, m1 --------------------- rs1, m1
- | |
- | |
- v v
- c2, ms2, m2 --------------------- rs2, m2
+ st1 --------------- st2
+ | |
+ t| *|t
+ | |
+ v v
+ st1'--------------- st2'
>>
- Left: execution of one Mach instruction. Right: execution of zero, one
- or several instructions. Precondition (top): agreement between
- the Mach register set [ms1] and the PPC register set [rs1]; moreover,
- [rs1 PC] points to the translation of code [c1]. Postcondition (bottom):
- similar.
+ The invariant is the [match_states] predicate below, which includes:
+- The PPC code pointed by the PC register is the translation of
+ the current Mach code sequence.
+- Mach register values and PPC register values agree.
*)
-Definition exec_instr_prop
- (f: Mach.function) (sp: val)
- (c1: Mach.code) (ms1: Mach.regset) (m1: mem) (t: trace)
- (c2: Mach.code) (ms2: Mach.regset) (m2: mem) :=
- forall rs1
- (WTF: wt_function f)
- (INCL: incl c1 f.(fn_code))
- (AT: transl_code_at_pc (rs1 PC) f c1)
- (AG: agree ms1 sp rs1),
- exists rs2,
- agree ms2 sp rs2
- /\ exec_steps tge rs1 m1 t rs2 m2
- /\ transl_code_at_pc (rs2 PC) f c2.
-
-Definition exec_function_body_prop
- (f: Mach.function) (parent: val) (ra: val)
- (ms1: Mach.regset) (m1: mem) (t: trace)
- (ms2: Mach.regset) (m2: mem) :=
- forall rs1
- (WTRA: Val.has_type ra Tint)
- (RALR: rs1 LR = ra)
- (WTF: wt_function f)
- (AT: Genv.find_funct ge (rs1 PC) = Some (Internal f))
- (AG: agree ms1 parent rs1),
- exists rs2,
- agree ms2 parent rs2
- /\ exec_steps tge rs1 m1 t rs2 m2
- /\ rs2 PC = rs1 LR.
-
-Definition exec_function_prop
- (f: Mach.fundef) (parent: val)
- (ms1: Mach.regset) (m1: mem) (t: trace)
- (ms2: Mach.regset) (m2: mem) :=
- forall rs1
- (WTF: wt_fundef f)
- (AT: Genv.find_funct ge (rs1 PC) = Some f)
- (AG: agree ms1 parent rs1)
- (WTRA: Val.has_type (rs1 LR) Tint),
- exists rs2,
- agree ms2 parent rs2
- /\ exec_steps tge rs1 m1 t rs2 m2
- /\ rs2 PC = rs1 LR.
-
-(** We show each case of the inductive proof of simulation as a separate
- lemma. *)
+Inductive match_stack: list Machconcr.stackframe -> Prop :=
+ | match_stack_nil:
+ match_stack nil
+ | match_stack_cons: forall fb sp ra c s f,
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ wt_function f ->
+ incl c f.(fn_code) ->
+ transl_code_at_pc ra fb f c ->
+ match_stack s ->
+ match_stack (Stackframe fb sp ra c :: s).
+
+Inductive match_states: Machconcr.state -> PPC.state -> Prop :=
+ | match_states_intro:
+ forall s fb sp c ms m rs f
+ (STACKS: match_stack s)
+ (FIND: Genv.find_funct_ptr ge fb = Some (Internal f))
+ (WTF: wt_function f)
+ (INCL: incl c f.(fn_code))
+ (AT: transl_code_at_pc (rs PC) fb f c)
+ (AG: agree ms sp rs),
+ match_states (Machconcr.State s fb sp c ms m)
+ (PPC.State rs m)
+ | match_states_call:
+ forall s fb ms m rs
+ (STACKS: match_stack s)
+ (AG: agree ms (parent_sp s) rs)
+ (ATPC: rs PC = Vptr fb Int.zero)
+ (ATLR: rs LR = parent_ra s),
+ match_states (Machconcr.Callstate s fb ms m)
+ (PPC.State rs m)
+ | match_states_return:
+ forall s ms m rs
+ (STACKS: match_stack s)
+ (AG: agree ms (parent_sp s) rs)
+ (ATPC: rs PC = parent_ra s),
+ match_states (Machconcr.Returnstate s ms m)
+ (PPC.State rs m).
+
+Lemma exec_straight_steps:
+ forall s fb sp m1 f c1 rs1 c2 m2 ms2,
+ match_stack s ->
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ wt_function f ->
+ incl c2 f.(fn_code) ->
+ transl_code_at_pc (rs1 PC) fb f c1 ->
+ (exists rs2,
+ exec_straight tge (transl_function f) (transl_code c1) rs1 m1 (transl_code c2) rs2 m2
+ /\ agree ms2 sp rs2) ->
+ exists st',
+ plus step tge (State rs1 m1) E0 st' /\
+ match_states (Machconcr.State s fb sp c2 ms2 m2) st'.
+Proof.
+ intros. destruct H4 as [rs2 [A B]].
+ exists (State rs2 m2); split.
+ eapply exec_straight_exec; eauto.
+ econstructor; eauto. eapply exec_straight_at; eauto.
+Qed.
+
+(** We need to show that, in the simulation diagram, we cannot
+ take infinitely many Mach transitions that correspond to zero
+ transitions on the PPC side. Actually, all Mach transitions
+ correspond to at least one PPC transition, except the
+ transition from [Machconcr.Returnstate] to [Machconcr.State].
+ So, the following integer measure will suffice to rule out
+ the unwanted behaviour. *)
+
+Definition measure (s: Machconcr.state) : nat :=
+ match s with
+ | Machconcr.State _ _ _ _ _ _ => 0%nat
+ | Machconcr.Callstate _ _ _ _ => 0%nat
+ | Machconcr.Returnstate _ _ _ => 1%nat
+ end.
+
+(** We show the simulation diagram by case analysis on the Mach transition
+ on the left. Since the proof is large, we break it into one lemma
+ per transition. *)
+
+Definition exec_instr_prop (s1: Machconcr.state) (t: trace) (s2: Machconcr.state) : Prop :=
+ 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.
+
Lemma exec_Mlabel_prop:
- forall (f : function) (sp : val) (lbl : Mach.label)
- (c : list Mach.instruction) (rs : Mach.regset) (m : mem),
- exec_instr_prop f sp (Mlabel lbl :: c) rs m E0 c rs m.
+ forall (s : list stackframe) (fb : block) (sp : val)
+ (lbl : Mach.label) (c : list Mach.instruction) (ms : Mach.regset)
+ (m : mem),
+ exec_instr_prop (Machconcr.State s fb sp (Mlabel lbl :: c) ms m) E0
+ (Machconcr.State s fb sp c ms m).
Proof.
- intros; red; intros.
- assert (exec_straight tge (transl_function f)
- (transl_code (Mlabel lbl :: c)) rs1 m
- (transl_code c) (nextinstr rs1) m).
+ intros; red; intros; inv MS.
+ left; eapply exec_straight_steps; eauto with coqlib.
+ exists (nextinstr rs); split.
simpl. apply exec_straight_one. reflexivity. reflexivity.
- exists (nextinstr rs1). split. apply agree_nextinstr; auto.
- eapply exec_straight_steps; eauto.
+ apply agree_nextinstr; auto.
Qed.
Lemma exec_Mgetstack_prop:
- forall (f : function) (sp : val) (ofs : int) (ty : typ) (dst : mreg)
- (c : list Mach.instruction) (ms : Mach.regset) (m : mem) (v : val),
- load_stack m sp ty ofs = Some v ->
- exec_instr_prop f sp (Mgetstack ofs ty dst :: c) ms m E0 c (Regmap.set dst v ms) m.
+ forall (s : list stackframe) (fb : block) (sp : val) (ofs : int)
+ (ty : typ) (dst : mreg) (c : list Mach.instruction)
+ (ms : Mach.regset) (m : mem) (v : val),
+ load_stack m sp ty ofs = Some v ->
+ exec_instr_prop (Machconcr.State s fb sp (Mgetstack ofs ty dst :: c) ms m) E0
+ (Machconcr.State s fb sp c (Regmap.set dst v ms) m).
Proof.
- intros; red; intros.
+ intros; red; intros; inv MS.
unfold load_stack in H.
generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
intro WTI. inversion WTI.
rewrite (sp_val _ _ _ AG) in H.
assert (NOTE: GPR1 <> GPR0). congruence.
generalize (loadind_correct tge (transl_function f) GPR1 ofs ty
- dst (transl_code c) rs1 m v H H1 NOTE).
+ dst (transl_code c) rs m v H H1 NOTE).
intros [rs2 [EX [RES OTH]]].
- exists rs2. split.
- apply agree_exten_2 with (rs1#(preg_of dst) <- v).
+ left; eapply exec_straight_steps; eauto with coqlib.
+ simpl. exists rs2; split. auto.
+ apply agree_exten_2 with (rs#(preg_of dst) <- v).
auto with ppcgen.
intros. case (preg_eq r0 (preg_of dst)); intro.
subst r0. rewrite Pregmap.gss. auto.
- rewrite Pregmap.gso; auto.
- eapply exec_straight_steps; eauto.
+ rewrite Pregmap.gso; auto.
Qed.
Lemma exec_Msetstack_prop:
- forall (f : function) (sp : val) (src : mreg) (ofs : int) (ty : typ)
- (c : list Mach.instruction) (ms : mreg -> val) (m m' : mem),
- store_stack m sp ty ofs (ms src) = Some m' ->
- exec_instr_prop f sp (Msetstack src ofs ty :: c) ms m E0 c ms m'.
+ forall (s : list stackframe) (fb : block) (sp : val) (src : mreg)
+ (ofs : int) (ty : typ) (c : list Mach.instruction)
+ (ms : mreg -> val) (m m' : mem),
+ store_stack m sp ty ofs (ms src) = Some m' ->
+ exec_instr_prop (Machconcr.State s fb sp (Msetstack src ofs ty :: c) ms m) E0
+ (Machconcr.State s fb sp c ms m').
Proof.
- intros; red; intros.
+ intros; red; intros; inv MS.
unfold store_stack in H.
generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
intro WTI. inversion WTI.
rewrite (sp_val _ _ _ AG) in H.
- rewrite (preg_val ms sp rs1) in H; auto.
+ rewrite (preg_val ms sp rs) in H; auto.
assert (NOTE: GPR1 <> GPR0). congruence.
generalize (storeind_correct tge (transl_function f) GPR1 ofs ty
- src (transl_code c) rs1 m m' H H2 NOTE).
+ src (transl_code c) rs m m' H H1 NOTE).
intros [rs2 [EX OTH]].
- exists rs2. split.
- apply agree_exten_2 with rs1; auto.
- eapply exec_straight_steps; eauto.
+ left; eapply exec_straight_steps; eauto with coqlib.
+ exists rs2; split; auto.
+ apply agree_exten_2 with rs; auto.
Qed.
Lemma exec_Mgetparam_prop:
- forall (f : function) (sp parent : val) (ofs : int) (ty : typ)
- (dst : mreg) (c : list Mach.instruction) (ms : Mach.regset)
- (m : mem) (v : val),
- load_stack m sp Tint (Int.repr 0) = Some parent ->
- load_stack m parent ty ofs = Some v ->
- exec_instr_prop f sp (Mgetparam ofs ty dst :: c) ms m E0 c (Regmap.set dst v ms) m.
+ forall (s : list stackframe) (fb : block) (sp parent : val)
+ (ofs : int) (ty : typ) (dst : mreg) (c : list Mach.instruction)
+ (ms : Mach.regset) (m : mem) (v : val),
+ load_stack m sp Tint (Int.repr 0) = Some parent ->
+ load_stack m parent ty ofs = Some v ->
+ exec_instr_prop (Machconcr.State s fb sp (Mgetparam ofs ty dst :: c) ms m) E0
+ (Machconcr.State s fb sp c (Regmap.set dst v ms) m).
Proof.
- intros; red; intros.
- set (rs2 := nextinstr (rs1#GPR2 <- parent)).
+ intros; red; intros; inv MS.
+ set (rs2 := nextinstr (rs#GPR2 <- parent)).
assert (EX1: exec_straight tge (transl_function f)
- (transl_code (Mgetparam ofs ty dst :: c)) rs1 m
+ (transl_code (Mgetparam ofs ty dst :: c)) rs m
(loadind GPR2 ofs ty dst (transl_code c)) rs2 m).
simpl. apply exec_straight_one.
simpl. unfold load1. rewrite gpr_or_zero_not_zero; auto with ppcgen.
- unfold const_low. rewrite <- (sp_val ms sp rs1); auto.
+ unfold const_low. rewrite <- (sp_val ms sp rs); auto.
unfold load_stack in H. simpl chunk_of_type in H.
rewrite H. reflexivity. reflexivity.
generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
@@ -696,64 +777,48 @@ Proof.
generalize (loadind_correct tge (transl_function f) GPR2 ofs ty
dst (transl_code c) rs2 m v H0 H2 NOTE).
intros [rs3 [EX2 [RES OTH]]].
- exists rs3. split.
+ left; eapply exec_straight_steps; eauto with coqlib.
+ exists rs3; split; simpl.
+ eapply exec_straight_trans; eauto.
apply agree_exten_2 with (rs2#(preg_of dst) <- v).
unfold rs2; auto with ppcgen.
intros. case (preg_eq r0 (preg_of dst)); intro.
subst r0. rewrite Pregmap.gss. auto.
rewrite Pregmap.gso; auto.
- eapply exec_straight_steps; eauto.
- eapply exec_straight_trans; eauto.
-Qed.
-
-Lemma exec_straight_exec_prop:
- forall f sp c1 rs1 m1 c2 m2 ms',
- transl_code_at_pc (rs1 PC) f c1 ->
- (exists rs2,
- exec_straight tge (transl_function f)
- (transl_code c1) rs1 m1
- (transl_code c2) rs2 m2
- /\ agree ms' sp rs2) ->
- (exists rs2,
- agree ms' sp rs2
- /\ exec_steps tge rs1 m1 E0 rs2 m2
- /\ transl_code_at_pc (rs2 PC) f c2).
-Proof.
- intros until ms'. intros TRANS1 [rs2 [EX AG]].
- exists rs2. split. assumption.
- eapply exec_straight_steps; eauto.
Qed.
Lemma exec_Mop_prop:
- forall (f : function) (sp : val) (op : operation) (args : list mreg)
- (res : mreg) (c : list Mach.instruction) (ms: Mach.regset)
- (m : mem) (v: val),
- eval_operation ge sp op ms ## args = Some v ->
- exec_instr_prop f sp (Mop op args res :: c) ms m E0 c (Regmap.set res v ms) m.
+ forall (s : list stackframe) (fb : block) (sp : val) (op : operation)
+ (args : list mreg) (res : mreg) (c : list Mach.instruction)
+ (ms : mreg -> val) (m : mem) (v : val),
+ eval_operation ge sp op ms ## args m = Some v ->
+ exec_instr_prop (Machconcr.State s fb sp (Mop op args res :: c) ms m) E0
+ (Machconcr.State s fb sp c (Regmap.set res v ms) m).
Proof.
- intros; red; intros.
+ intros; red; intros; inv MS.
generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
- intro WTI.
- eapply exec_straight_exec_prop; eauto.
+ intro WTI.
+ left; eapply exec_straight_steps; eauto with coqlib.
simpl. eapply transl_op_correct; auto.
rewrite <- H. apply eval_operation_preserved. exact symbols_preserved.
Qed.
Lemma exec_Mload_prop:
- forall (f : function) (sp : val) (chunk : memory_chunk)
- (addr : addressing) (args : list mreg) (dst : mreg)
- (c : list Mach.instruction) (ms: Mach.regset) (m : mem)
- (a v : val),
- eval_addressing ge sp addr ms ## args = Some a ->
- loadv chunk m a = Some v ->
- exec_instr_prop f sp (Mload chunk addr args dst :: c) ms m E0 c (Regmap.set dst v ms) m.
+ forall (s : list stackframe) (fb : block) (sp : val)
+ (chunk : memory_chunk) (addr : addressing) (args : list mreg)
+ (dst : mreg) (c : list Mach.instruction) (ms : mreg -> val)
+ (m : mem) (a v : val),
+ eval_addressing ge sp addr ms ## args = Some a ->
+ loadv chunk m a = Some v ->
+ exec_instr_prop (Machconcr.State s fb sp (Mload chunk addr args dst :: c) ms m)
+ E0 (Machconcr.State s fb sp c (Regmap.set dst v ms) m).
Proof.
- intros; red; intros.
+ intros; red; intros; inv MS.
generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
intro WTI; inversion WTI.
assert (eval_addressing tge sp addr ms##args = Some a).
rewrite <- H. apply eval_addressing_preserved. exact symbols_preserved.
- eapply exec_straight_exec_prop; eauto.
+ left; eapply exec_straight_steps; eauto with coqlib;
destruct chunk; simpl; simpl in H6;
(* all cases but Mint8signed *)
try (eapply transl_load_correct; eauto;
@@ -776,7 +841,7 @@ Proof.
(Plbz (ireg_of dst)) (Plbzx (ireg_of dst))
Mint8unsigned addr args
(Pextsb (ireg_of dst) (ireg_of dst) :: transl_code c)
- ms sp rs1 m dst a v'
+ ms sp rs m dst a v'
X1 X2 AG H3 H7 LOAD').
intros [rs2 [EX1 AG1]].
exists (nextinstr (rs2#(ireg_of dst) <- v)).
@@ -788,190 +853,298 @@ Proof.
Qed.
Lemma exec_Mstore_prop:
- forall (f : function) (sp : val) (chunk : memory_chunk)
- (addr : addressing) (args : list mreg) (src : mreg)
- (c : list Mach.instruction) (ms: Mach.regset) (m m' : mem)
- (a : val),
- eval_addressing ge sp addr ms ## args = Some a ->
- storev chunk m a (ms src) = Some m' ->
- exec_instr_prop f sp (Mstore chunk addr args src :: c) ms m E0 c ms m'.
+ forall (s : list stackframe) (fb : block) (sp : val)
+ (chunk : memory_chunk) (addr : addressing) (args : list mreg)
+ (src : mreg) (c : list Mach.instruction) (ms : mreg -> val)
+ (m m' : mem) (a : val),
+ eval_addressing ge sp addr ms ## args = Some a ->
+ storev chunk m a (ms src) = Some m' ->
+ exec_instr_prop (Machconcr.State s fb sp (Mstore chunk addr args src :: c) ms m) E0
+ (Machconcr.State s fb sp c ms m').
Proof.
- intros; red; intros.
+ intros; red; intros; inv MS.
generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
intro WTI; inversion WTI.
rewrite <- (eval_addressing_preserved symbols_preserved) in H.
- eapply exec_straight_exec_prop; eauto.
+ left; eapply exec_straight_steps; eauto with coqlib.
destruct chunk; simpl; simpl in H6;
- try (rewrite storev_8_signed_unsigned in H);
- try (rewrite storev_16_signed_unsigned in H);
+ try (rewrite storev_8_signed_unsigned in H0);
+ try (rewrite storev_16_signed_unsigned in H0);
simpl; eapply transl_store_correct; eauto;
intros; unfold preg_of; rewrite H6; reflexivity.
Qed.
-Hypothesis wt_prog: wt_program prog.
-
Lemma exec_Mcall_prop:
- forall (f : function) (sp : val) (sig : signature)
- (mos : mreg + ident) (c : list Mach.instruction) (ms : Mach.regset)
- (m : mem) (f' : Mach.fundef) (t: trace) (ms' : Mach.regset) (m' : mem),
- find_function ge mos ms = Some f' ->
- exec_function ge f' sp ms m t ms' m' ->
- exec_function_prop f' sp ms m t ms' m' ->
- exec_instr_prop f sp (Mcall sig mos :: c) ms m t c ms' m'.
+ forall (s : list stackframe) (fb : block) (sp : val)
+ (sig : signature) (ros : mreg + ident) (c : Mach.code)
+ (ms : Mach.regset) (m : mem) (f : function) (f' : block)
+ (ra : int),
+ find_function_ptr ge ros ms = Some f' ->
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ return_address_offset f c ra ->
+ exec_instr_prop (Machconcr.State s fb sp (Mcall sig ros :: c) ms m) E0
+ (Callstate (Stackframe fb sp (Vptr fb ra) c :: s) f' ms m).
Proof.
- intros; red; intros.
+ intros; red; intros; inv MS.
+ assert (f0 = f) by congruence. subst f0.
generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
intro WTI. inversion WTI.
- inversion AT.
- assert (WTF': wt_fundef f').
- destruct mos; simpl in H.
- apply (Genv.find_funct_prop wt_fundef wt_prog H).
- destruct (Genv.find_symbol ge i); try discriminate.
- apply (Genv.find_funct_ptr_prop wt_fundef wt_prog H).
+ inv AT.
assert (NOOV: code_size (transl_function f) <= Int.max_unsigned).
eapply functions_transl_no_overflow; eauto.
- destruct mos; simpl in H; simpl transl_code in H7.
+ destruct ros; simpl in H; simpl transl_code in H7.
(* Indirect call *)
generalize (code_tail_next_int _ _ _ _ NOOV H7). intro CT1.
generalize (code_tail_next_int _ _ _ _ NOOV CT1). intro CT2.
- set (rs2 := nextinstr (rs1#CTR <- (ms m0))).
+ set (rs2 := nextinstr (rs#CTR <- (ms m0))).
set (rs3 := rs2 #LR <- (Val.add rs2#PC Vone) #PC <- (ms m0)).
- assert (TFIND: Genv.find_funct ge (rs3#PC) = Some f').
- unfold rs3. rewrite Pregmap.gss. auto.
+ assert (ATPC: rs3 PC = Vptr f' Int.zero).
+ change (rs3 PC) with (ms m0).
+ destruct (ms m0); try discriminate.
+ generalize H; predSpec Int.eq Int.eq_spec i Int.zero; intros; congruence.
+ exploit return_address_offset_correct; eauto. constructor; eauto.
+ intro RA_EQ.
+ assert (ATLR: rs3 LR = Vptr fb ra).
+ rewrite RA_EQ.
+ change (rs3 LR) with (Val.add (Val.add (rs PC) Vone) Vone).
+ rewrite <- H5. reflexivity.
assert (AG3: agree ms sp rs3).
unfold rs3, rs2; auto 8 with ppcgen.
- assert (WTRA: Val.has_type rs3#LR Tint).
- change rs3#LR with (Val.add (Val.add rs1#PC Vone) Vone).
- rewrite <- H5. exact I.
- generalize (H1 rs3 WTF' TFIND AG3 WTRA).
- intros [rs4 [AG4 [EXF' PC4]]].
- exists rs4. split. auto. split.
- apply exec_trans with E0 rs2 m t. apply exec_one. econstructor.
- eauto. apply functions_transl. eexact H6.
- rewrite find_instr_tail. rewrite H7. reflexivity.
- simpl. rewrite <- (ireg_val ms sp rs1); auto.
- apply exec_trans with E0 rs3 m t. apply exec_one. econstructor.
- unfold rs2, nextinstr. rewrite Pregmap.gss.
- rewrite Pregmap.gso. rewrite <- H5. simpl. reflexivity.
- discriminate. apply functions_transl. eexact H6.
- rewrite find_instr_tail. rewrite CT1. reflexivity.
- simpl. replace (rs2 CTR) with (ms m0). reflexivity.
- unfold rs2. rewrite nextinstr_inv. rewrite Pregmap.gss.
- auto. discriminate.
- exact EXF'. traceEq. traceEq.
- rewrite PC4. unfold rs3. rewrite Pregmap.gso. rewrite Pregmap.gss.
- unfold rs2, nextinstr. rewrite Pregmap.gss. rewrite Pregmap.gso.
- rewrite <- H5. simpl. constructor. auto. auto.
- discriminate. discriminate.
+ left; exists (State rs3 m); split.
+ apply plus_left with E0 (State rs2 m) E0.
+ econstructor. eauto. apply functions_transl. eexact H0.
+ eapply find_instr_tail. eauto.
+ simpl. rewrite <- (ireg_val ms sp rs); auto.
+ apply star_one. econstructor.
+ change (rs2 PC) with (Val.add (rs PC) Vone). rewrite <- H5.
+ simpl. auto.
+ apply functions_transl. eexact H0.
+ eapply find_instr_tail. eauto.
+ simpl. reflexivity.
+ traceEq.
+ econstructor; eauto.
+ econstructor; eauto with coqlib.
+ rewrite RA_EQ. econstructor; eauto.
(* Direct call *)
- caseEq (Genv.find_symbol ge i). intros fblock FINDS.
- rewrite FINDS in H.
generalize (code_tail_next_int _ _ _ _ NOOV H7). intro CT1.
- set (rs2 := rs1 #LR <- (Val.add rs1#PC Vone) #PC <- (symbol_offset tge i Int.zero)).
- assert (TFIND: Genv.find_funct ge (rs2#PC) = Some f').
- unfold rs2. rewrite Pregmap.gss.
- unfold symbol_offset. rewrite symbols_preserved.
- rewrite FINDS.
- rewrite Genv.find_funct_find_funct_ptr. assumption.
+ set (rs2 := rs #LR <- (Val.add rs#PC Vone) #PC <- (symbol_offset tge i Int.zero)).
+ assert (ATPC: rs2 PC = Vptr f' Int.zero).
+ change (rs2 PC) with (symbol_offset tge i Int.zero).
+ unfold symbol_offset. rewrite symbols_preserved. rewrite H. auto.
+ exploit return_address_offset_correct; eauto. constructor; eauto.
+ intro RA_EQ.
+ assert (ATLR: rs2 LR = Vptr fb ra).
+ rewrite RA_EQ.
+ change (rs2 LR) with (Val.add (rs PC) Vone).
+ rewrite <- H5. reflexivity.
assert (AG2: agree ms sp rs2).
unfold rs2; auto 8 with ppcgen.
- assert (WTRA: Val.has_type rs2#LR Tint).
- change rs2#LR with (Val.add rs1#PC Vone).
- rewrite <- H5. exact I.
- generalize (H1 rs2 WTF' TFIND AG2 WTRA).
- intros [rs3 [AG3 [EXF' PC3]]].
- exists rs3. split. auto. split.
- apply exec_trans with E0 rs2 m t. apply exec_one. econstructor.
- eauto. apply functions_transl. eexact H6.
- rewrite find_instr_tail. rewrite H7. reflexivity.
- simpl. reflexivity.
- exact EXF'. traceEq.
- rewrite PC3. unfold rs2. rewrite Pregmap.gso. rewrite Pregmap.gss.
- rewrite <- H5. simpl. constructor. auto. auto.
- discriminate.
- intro FINDS. rewrite FINDS in H. discriminate.
+ left; exists (State rs2 m); split.
+ apply plus_one. econstructor.
+ eauto.
+ apply functions_transl. eexact H0.
+ eapply find_instr_tail. eauto.
+ simpl. reflexivity.
+ econstructor; eauto with coqlib.
+ econstructor; eauto with coqlib.
+ rewrite RA_EQ. econstructor; eauto.
+Qed.
+
+Lemma exec_Mtailcall_prop:
+ forall (s : list stackframe) (fb stk : block) (soff : int)
+ (sig : signature) (ros : mreg + ident) (c : list Mach.instruction)
+ (ms : Mach.regset) (m : mem) (f' : block),
+ find_function_ptr ge ros ms = Some f' ->
+ load_stack m (Vptr stk soff) Tint (Int.repr 0) = Some (parent_sp s) ->
+ load_stack m (Vptr stk soff) Tint (Int.repr 12) = Some (parent_ra s) ->
+ exec_instr_prop
+ (Machconcr.State s fb (Vptr stk soff) (Mtailcall sig ros :: c) ms m) E0
+ (Callstate s f' ms (free m stk)).
+Proof.
+ intros; red; intros; inv MS.
+ generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
+ intro WTI. inversion WTI.
+ inversion AT. subst b f0 c0.
+ assert (NOOV: code_size (transl_function f) <= Int.max_unsigned).
+ eapply functions_transl_no_overflow; eauto.
+ destruct ros; simpl in H; simpl in H8.
+ (* Indirect call *)
+ set (rs2 := nextinstr (rs#CTR <- (ms m0))).
+ set (rs3 := nextinstr (rs2#GPR2 <- (parent_ra s))).
+ set (rs4 := nextinstr (rs3#LR <- (parent_ra s))).
+ set (rs5 := nextinstr (rs4#GPR1 <- (parent_sp s))).
+ set (rs6 := rs5#PC <- (rs5 CTR)).
+ assert (exec_straight tge (transl_function f)
+ (transl_code (Mtailcall sig (inl ident m0) :: c)) rs m
+ (Pbctr :: transl_code c) rs5 (free m stk)).
+ simpl. apply exec_straight_step with rs2 m.
+ simpl. rewrite <- (ireg_val _ _ _ _ AG H5). reflexivity. reflexivity.
+ apply exec_straight_step with rs3 m.
+ simpl. unfold load1. rewrite gpr_or_zero_not_zero. unfold const_low.
+ change (rs2 GPR1) with (rs GPR1). rewrite <- (sp_val _ _ _ AG).
+ simpl. unfold load_stack in H1. simpl in H1. rewrite H1.
+ reflexivity. discriminate. reflexivity.
+ apply exec_straight_step with rs4 m.
+ simpl. reflexivity. reflexivity.
+ apply exec_straight_one.
+ simpl. change (rs4 GPR1) with (rs GPR1). rewrite <- (sp_val _ _ _ AG).
+ unfold load_stack in H0; simpl in H0. rewrite Int.add_zero in H0.
+ simpl. rewrite H0. reflexivity. reflexivity.
+ left; exists (State rs6 (free m stk)); split.
+ (* execution *)
+ eapply plus_right'. eapply exec_straight_exec; eauto.
+ econstructor.
+ change (rs5 PC) with (Val.add (Val.add (Val.add (Val.add (rs PC) Vone) Vone) Vone) Vone).
+ rewrite <- H6; simpl. eauto.
+ eapply functions_transl; eauto.
+ eapply find_instr_tail.
+ repeat (eapply code_tail_next_int; auto). eauto.
+ simpl. reflexivity. traceEq.
+ (* match states *)
+ econstructor; eauto.
+ assert (AG4: agree ms (Vptr stk soff) rs4).
+ unfold rs4, rs3, rs2; auto 10 with ppcgen.
+ assert (AG5: agree ms (parent_sp s) rs5).
+ unfold rs5. apply agree_nextinstr.
+ split. reflexivity. intros. inv AG4. rewrite H11.
+ rewrite Pregmap.gso; auto with ppcgen.
+ unfold rs6; auto with ppcgen.
+ change (rs6 PC) with (ms m0).
+ generalize H. destruct (ms m0); try congruence.
+ predSpec Int.eq Int.eq_spec i Int.zero; intros; congruence.
+ (* direct call *)
+ set (rs2 := nextinstr (rs#GPR2 <- (parent_ra s))).
+ set (rs3 := nextinstr (rs2#LR <- (parent_ra s))).
+ set (rs4 := nextinstr (rs3#GPR1 <- (parent_sp s))).
+ set (rs5 := rs4#PC <- (Vptr f' Int.zero)).
+ assert (exec_straight tge (transl_function f)
+ (transl_code (Mtailcall sig (inr mreg i) :: c)) rs m
+ (Pbs i :: transl_code c) rs4 (free m stk)).
+ simpl. apply exec_straight_step with rs2 m.
+ simpl. unfold load1. rewrite gpr_or_zero_not_zero. unfold const_low.
+ rewrite <- (sp_val _ _ _ AG).
+ simpl. unfold load_stack in H1. simpl in H1. rewrite H1.
+ reflexivity. discriminate. reflexivity.
+ apply exec_straight_step with rs3 m.
+ simpl. reflexivity. reflexivity.
+ apply exec_straight_one.
+ simpl. change (rs3 GPR1) with (rs GPR1). rewrite <- (sp_val _ _ _ AG).
+ unfold load_stack in H0; simpl in H0. rewrite Int.add_zero in H0.
+ simpl. rewrite H0. reflexivity. reflexivity.
+ left; exists (State rs5 (free m stk)); split.
+ (* execution *)
+ eapply plus_right'. eapply exec_straight_exec; eauto.
+ econstructor.
+ change (rs4 PC) with (Val.add (Val.add (Val.add (rs PC) Vone) Vone) Vone).
+ rewrite <- H6; simpl. eauto.
+ eapply functions_transl; eauto.
+ eapply find_instr_tail.
+ repeat (eapply code_tail_next_int; auto). eauto.
+ simpl. unfold symbol_offset. rewrite symbols_preserved. rewrite H.
+ reflexivity. traceEq.
+ (* match states *)
+ econstructor; eauto.
+ assert (AG3: agree ms (Vptr stk soff) rs3).
+ unfold rs3, rs2; auto 10 with ppcgen.
+ assert (AG4: agree ms (parent_sp s) rs4).
+ unfold rs4. apply agree_nextinstr.
+ split. reflexivity. intros. inv AG3. rewrite H11.
+ rewrite Pregmap.gso; auto with ppcgen.
+ unfold rs5; auto with ppcgen.
Qed.
Lemma exec_Malloc_prop:
- forall (f : function) (sp : val) (c : list Mach.instruction)
- (ms : Mach.regset) (m : mem) (sz : int) (m' : mem) (blk : block),
+ forall (s : list stackframe) (fb : block) (sp : val)
+ (c : list Mach.instruction) (ms : mreg -> val) (m : mem) (sz : int)
+ (m' : mem) (blk : block),
ms Conventions.loc_alloc_argument = Vint sz ->
- Mem.alloc m 0 (Int.signed sz) = (m', blk) ->
- exec_instr_prop f sp (Malloc :: c) ms m E0 c
- (Regmap.set Conventions.loc_alloc_result (Vptr blk Int.zero) ms) m'.
+ alloc m 0 (Int.signed sz) = (m', blk) ->
+ exec_instr_prop (Machconcr.State s fb sp (Malloc :: c) ms m) E0
+ (Machconcr.State s fb sp c
+ (Regmap.set (Conventions.loc_alloc_result) (Vptr blk Int.zero) ms) m').
Proof.
- intros; red; intros.
- eapply exec_straight_exec_prop; eauto.
+ intros; red; intros; inv MS.
+ left; eapply exec_straight_steps; eauto with coqlib.
simpl. eapply transl_alloc_correct; eauto.
Qed.
Lemma exec_Mgoto_prop:
- forall (f : function) (sp : val) (lbl : Mach.label)
- (c : list Mach.instruction) (ms : Mach.regset) (m : mem)
- (c' : Mach.code),
- Mach.find_label lbl (fn_code f) = Some c' ->
- exec_instr_prop f sp (Mgoto lbl :: c) ms m E0 c' ms m.
+ forall (s : list stackframe) (fb : block) (f : function) (sp : val)
+ (lbl : Mach.label) (c : list Mach.instruction) (ms : Mach.regset)
+ (m : mem) (c' : Mach.code),
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ Mach.find_label lbl (fn_code f) = Some c' ->
+ exec_instr_prop (Machconcr.State s fb sp (Mgoto lbl :: c) ms m) E0
+ (Machconcr.State s fb sp c' ms m).
Proof.
- intros; red; intros.
- inversion AT.
- generalize (find_label_goto_label f lbl rs1 m _ _ _ H1 (sym_equal H0) H).
+ intros; red; intros; inv MS.
+ assert (f0 = f) by congruence. subst f0.
+ inv AT. simpl in H3.
+ generalize (find_label_goto_label f lbl rs m _ _ _ FIND (sym_equal H1) H0).
intros [rs2 [GOTO [AT2 INV]]].
- exists rs2. split. apply agree_exten_2 with rs1; auto.
- split. inversion AT. apply exec_one. econstructor; eauto.
- apply functions_transl; eauto.
- rewrite find_instr_tail. rewrite H7. simpl. reflexivity.
- simpl. rewrite GOTO. auto. auto.
+ left; exists (State rs2 m); split.
+ apply plus_one. econstructor; eauto.
+ apply functions_transl; eauto.
+ eapply find_instr_tail; eauto.
+ simpl; auto.
+ econstructor; eauto.
+ eapply Mach.find_label_incl; eauto.
+ apply agree_exten_2 with rs; auto.
Qed.
Lemma exec_Mcond_true_prop:
- forall (f : function) (sp : val) (cond : condition)
- (args : list mreg) (lbl : Mach.label) (c : list Mach.instruction)
- (ms: Mach.regset) (m : mem) (c' : Mach.code),
- eval_condition cond ms ## args = Some true ->
- Mach.find_label lbl (fn_code f) = Some c' ->
- exec_instr_prop f sp (Mcond cond args lbl :: c) ms m E0 c' ms m.
+ forall (s : list stackframe) (fb : block) (f : function) (sp : val)
+ (cond : condition) (args : list mreg) (lbl : Mach.label)
+ (c : list Mach.instruction) (ms : mreg -> val) (m : mem)
+ (c' : Mach.code),
+ eval_condition cond ms ## args m = Some true ->
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ Mach.find_label lbl (fn_code f) = Some c' ->
+ exec_instr_prop (Machconcr.State s fb sp (Mcond cond args lbl :: c) ms m) E0
+ (Machconcr.State s fb sp c' ms m).
Proof.
- intros; red; intros.
+ intros; red; intros; inv MS. assert (f0 = f) by congruence. subst f0.
generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
- intro WTI. inversion WTI.
+ intro WTI. inv WTI.
pose (k1 :=
if snd (crbit_for_cond cond)
then Pbt (fst (crbit_for_cond cond)) lbl :: transl_code c
else Pbf (fst (crbit_for_cond cond)) lbl :: transl_code c).
generalize (transl_cond_correct tge (transl_function f)
- cond args k1 ms sp rs1 m true H2 AG H).
+ cond args k1 ms sp rs m true H3 AG H).
simpl. intros [rs2 [EX [RES AG2]]].
- inversion AT.
- generalize (functions_transl _ _ H6); intro FN.
- generalize (functions_transl_no_overflow _ _ H6); intro NOOV.
- simpl in H7.
- generalize (exec_straight_steps_2 _ _ _ _ _ _ _ EX
- NOOV _ _ (sym_equal H5) FN H7).
+ inv AT. simpl in H5.
+ generalize (functions_transl _ _ H4); intro FN.
+ generalize (functions_transl_no_overflow _ _ H4); intro NOOV.
+ exploit exec_straight_steps_2; eauto.
intros [ofs' [PC2 CT2]].
- generalize (find_label_goto_label f lbl rs2 m _ _ _ H6 PC2 H0).
+ generalize (find_label_goto_label f lbl rs2 m _ _ _ FIND PC2 H1).
intros [rs3 [GOTO [AT3 INV3]]].
- exists rs3. split.
- apply agree_exten_2 with rs2; auto.
- split. eapply exec_trans.
+ left; exists (State rs3 m); split.
+ eapply plus_right'.
eapply exec_straight_steps_1; eauto.
caseEq (snd (crbit_for_cond cond)); intro ISSET; rewrite ISSET in RES.
- apply exec_one. econstructor; eauto.
- rewrite find_instr_tail. rewrite CT2. unfold k1. rewrite ISSET. reflexivity.
+ econstructor; eauto.
+ eapply find_instr_tail. unfold k1 in CT2; rewrite ISSET in CT2. eauto.
simpl. rewrite RES. simpl. auto.
- apply exec_one. econstructor; eauto.
- rewrite find_instr_tail. rewrite CT2. unfold k1. rewrite ISSET. reflexivity.
+ econstructor; eauto.
+ eapply find_instr_tail. unfold k1 in CT2; rewrite ISSET in CT2. eauto.
simpl. rewrite RES. simpl. auto.
- traceEq. auto.
+ traceEq.
+ econstructor; eauto.
+ eapply Mach.find_label_incl; eauto.
+ apply agree_exten_2 with rs2; auto.
Qed.
Lemma exec_Mcond_false_prop:
- forall (f : function) (sp : val) (cond : condition)
- (args : list mreg) (lbl : Mach.label) (c : list Mach.instruction)
- (ms : Mach.regset) (m : mem),
- eval_condition cond ms ## args = Some false ->
- exec_instr_prop f sp (Mcond cond args lbl :: c) ms m E0 c ms m.
+ forall (s : list stackframe) (fb : block) (sp : val)
+ (cond : condition) (args : list mreg) (lbl : Mach.label)
+ (c : list Mach.instruction) (ms : mreg -> val) (m : mem),
+ eval_condition cond ms ## args m = Some false ->
+ exec_instr_prop (Machconcr.State s fb sp (Mcond cond args lbl :: c) ms m) E0
+ (Machconcr.State s fb sp c ms m).
Proof.
- intros; red; intros.
+ intros; red; intros; inv MS.
generalize (wt_function_instrs _ WTF _ (INCL _ (in_eq _ _))).
intro WTI. inversion WTI.
pose (k1 :=
@@ -979,12 +1152,11 @@ Proof.
then Pbt (fst (crbit_for_cond cond)) lbl :: transl_code c
else Pbf (fst (crbit_for_cond cond)) lbl :: transl_code c).
generalize (transl_cond_correct tge (transl_function f)
- cond args k1 ms sp rs1 m false H1 AG H).
+ cond args k1 ms sp rs m false H1 AG H).
simpl. intros [rs2 [EX [RES AG2]]].
- exists (nextinstr rs2).
- split. auto with ppcgen.
- eapply exec_straight_steps; eauto.
- eapply exec_straight_trans. eexact EX.
+ left; eapply exec_straight_steps; eauto with coqlib.
+ exists (nextinstr rs2); split.
+ simpl. eapply exec_straight_trans. eexact EX.
caseEq (snd (crbit_for_cond cond)); intro ISSET; rewrite ISSET in RES.
unfold k1; rewrite ISSET; apply exec_straight_one.
simpl. rewrite RES. reflexivity.
@@ -992,114 +1164,110 @@ Proof.
unfold k1; rewrite ISSET; apply exec_straight_one.
simpl. rewrite RES. reflexivity.
reflexivity.
+ auto with ppcgen.
Qed.
-Lemma exec_instr_incl:
- forall f sp c rs m t c' rs' m',
- Mach.exec_instr ge f sp c rs m t c' rs' m' ->
- incl c f.(fn_code) -> incl c' f.(fn_code).
+Lemma exec_Mreturn_prop:
+ forall (s : list stackframe) (fb stk : block) (soff : int)
+ (c : list Mach.instruction) (ms : Mach.regset) (m : mem),
+ load_stack m (Vptr stk soff) Tint (Int.repr 0) = Some (parent_sp s) ->
+ load_stack m (Vptr stk soff) Tint (Int.repr 12) = Some (parent_ra s) ->
+ exec_instr_prop (Machconcr.State s fb (Vptr stk soff) (Mreturn :: c) ms m) E0
+ (Returnstate s ms (free m stk)).
Proof.
- induction 1; intros; eauto with coqlib.
- eapply incl_find_label; eauto.
- eapply incl_find_label; eauto.
-Qed.
-
-Lemma exec_instrs_incl:
- forall f sp c rs m t c' rs' m',
- Mach.exec_instrs ge f sp c rs m t c' rs' m' ->
- incl c f.(fn_code) -> incl c' f.(fn_code).
-Proof.
- induction 1; intros.
- auto.
- eapply exec_instr_incl; eauto.
- eauto.
-Qed.
-
-Lemma exec_refl_prop:
- forall (f : function) (sp : val) (c : Mach.code) (ms : Mach.regset)
- (m : mem), exec_instr_prop f sp c ms m E0 c ms m.
-Proof.
- intros; red; intros.
- exists rs1. split. auto. split. apply exec_refl. auto.
-Qed.
-
-Lemma exec_one_prop:
- forall (f : function) (sp : val) (c : Mach.code) (ms : Mach.regset)
- (m : mem) (t: trace) (c' : Mach.code) (ms' : Mach.regset) (m' : mem),
- Mach.exec_instr ge f sp c ms m t c' ms' m' ->
- exec_instr_prop f sp c ms m t c' ms' m' ->
- exec_instr_prop f sp c ms m t c' ms' m'.
-Proof.
- auto.
+ intros; red; intros; inv MS.
+ set (rs2 := nextinstr (rs#GPR2 <- (parent_ra s))).
+ set (rs3 := nextinstr (rs2#LR <- (parent_ra s))).
+ set (rs4 := nextinstr (rs3#GPR1 <- (parent_sp s))).
+ set (rs5 := rs4#PC <- (parent_ra s)).
+ assert (exec_straight tge (transl_function f)
+ (transl_code (Mreturn :: c)) rs m
+ (Pblr :: transl_code c) rs4 (free m stk)).
+ simpl. apply exec_straight_three with rs2 m rs3 m.
+ simpl. unfold load1. rewrite gpr_or_zero_not_zero. unfold const_low.
+ unfold load_stack in H0. simpl in H0.
+ rewrite <- (sp_val _ _ _ AG). simpl. rewrite H0.
+ reflexivity. discriminate.
+ unfold rs3. change (parent_ra s) with rs2#GPR2. reflexivity.
+ simpl. change (rs3 GPR1) with (rs GPR1). rewrite <- (sp_val _ _ _ AG).
+ simpl.
+ unfold load_stack in H. simpl in H. rewrite Int.add_zero in H.
+ rewrite H. reflexivity.
+ reflexivity. reflexivity. reflexivity.
+ left; exists (State rs5 (free m stk)); split.
+ (* execution *)
+ apply plus_right' with E0 (State rs4 (free m stk)) E0.
+ eapply exec_straight_exec; eauto.
+ inv AT. econstructor.
+ change (rs4 PC) with (Val.add (Val.add (Val.add (rs PC) Vone) Vone) Vone).
+ rewrite <- H2. simpl. eauto.
+ apply functions_transl; eauto.
+ generalize (functions_transl_no_overflow _ _ H3); intro NOOV.
+ simpl in H4. eapply find_instr_tail.
+ eapply code_tail_next_int; auto.
+ eapply code_tail_next_int; auto.
+ eapply code_tail_next_int; eauto.
+ reflexivity. traceEq.
+ (* match states *)
+ econstructor; eauto.
+ assert (AG3: agree ms (Vptr stk soff) rs3).
+ unfold rs3, rs2; auto 10 with ppcgen.
+ assert (AG4: agree ms (parent_sp s) rs4).
+ split. reflexivity. intros. unfold rs4.
+ rewrite nextinstr_inv. rewrite Pregmap.gso.
+ elim AG3; auto. auto with ppcgen. auto with ppcgen.
+ unfold rs5; auto with ppcgen.
Qed.
-Lemma exec_trans_prop:
- forall (f : function) (sp : val) (c1 : Mach.code) (ms1 : Mach.regset)
- (m1 : mem) (t1: trace) (c2 : Mach.code) (ms2 : Mach.regset) (m2 : mem)
- (t2: trace) (c3 : Mach.code) (ms3 : Mach.regset) (m3 : mem) (t3: trace),
- exec_instrs ge f sp c1 ms1 m1 t1 c2 ms2 m2 ->
- exec_instr_prop f sp c1 ms1 m1 t1 c2 ms2 m2 ->
- exec_instrs ge f sp c2 ms2 m2 t2 c3 ms3 m3 ->
- exec_instr_prop f sp c2 ms2 m2 t2 c3 ms3 m3 ->
- t3 = t1 ** t2 ->
- exec_instr_prop f sp c1 ms1 m1 t3 c3 ms3 m3.
-Proof.
- intros; red; intros.
- generalize (H0 rs1 WTF INCL AT AG).
- intros [rs2 [AG2 [EX2 AT2]]].
- generalize (exec_instrs_incl _ _ _ _ _ _ _ _ _ H INCL). intro INCL2.
- generalize (H2 rs2 WTF INCL2 AT2 AG2).
- intros [rs3 [AG3 [EX3 AT3]]].
- exists rs3. split. auto. split. eapply exec_trans; eauto. auto.
-Qed.
+Hypothesis wt_prog: wt_program prog.
-Lemma exec_function_body_prop_:
- forall (f : function) (parent ra : val) (ms : Mach.regset) (m : mem)
- (t: trace) (ms' : Mach.regset) (m1 m2 m3 m4 : mem) (stk : block)
- (c : list Mach.instruction),
- alloc m (- fn_framesize f)
- (align_16_top (- fn_framesize f) (fn_stacksize f)) = (m1, stk) ->
- let sp := Vptr stk (Int.repr (- fn_framesize f)) in
- store_stack m1 sp Tint (Int.repr 0) parent = Some m2 ->
- store_stack m2 sp Tint (Int.repr 12) ra = Some m3 ->
- exec_instrs ge f sp (fn_code f) ms m3 t (Mreturn :: c) ms' m4 ->
- exec_instr_prop f sp (fn_code f) ms m3 t (Mreturn :: c) ms' m4 ->
- load_stack m4 sp Tint (Int.repr 0) = Some parent ->
- load_stack m4 sp Tint (Int.repr 12) = Some ra ->
- exec_function_body_prop f parent ra ms m t ms' (free m4 stk).
+Lemma exec_function_internal_prop:
+ forall (s : list stackframe) (fb : block) (ms : Mach.regset)
+ (m : mem) (f : function) (m1 m2 m3 : mem) (stk : block),
+ Genv.find_funct_ptr ge fb = Some (Internal f) ->
+ alloc m (- fn_framesize f)
+ (align_16_top (- fn_framesize f) (fn_stacksize f)) = (m1, stk) ->
+ let sp := Vptr stk (Int.repr (- fn_framesize f)) in
+ store_stack m1 sp Tint (Int.repr 0) (parent_sp s) = Some m2 ->
+ store_stack m2 sp Tint (Int.repr 12) (parent_ra s) = Some m3 ->
+ exec_instr_prop (Machconcr.Callstate s fb ms m) E0
+ (Machconcr.State s fb sp (fn_code f) ms m3).
Proof.
- intros; red; intros.
- generalize (Genv.find_funct_inv AT). intros [b EQPC].
- generalize AT. rewrite EQPC. rewrite Genv.find_funct_find_funct_ptr. intro FN.
- generalize (functions_transl_no_overflow _ _ FN); intro NOOV.
- set (rs2 := nextinstr (rs1#GPR1 <- sp #GPR2 <- Vundef)).
- set (rs3 := nextinstr (rs2#GPR2 <- ra)).
+ intros; red; intros; inv MS.
+ assert (WTF: wt_function f).
+ generalize (Genv.find_funct_ptr_prop wt_fundef wt_prog H); intro TY.
+ inversion TY; auto.
+ exploit functions_transl; eauto. intro TFIND.
+ generalize (functions_transl_no_overflow _ _ H); intro NOOV.
+ set (rs2 := nextinstr (rs#GPR1 <- sp #GPR2 <- Vundef)).
+ set (rs3 := nextinstr (rs2#GPR2 <- (parent_ra s))).
set (rs4 := nextinstr rs3).
- assert (exec_straight tge (transl_function f)
- (transl_function f) rs1 m
- (transl_code (fn_code f)) rs4 m3).
+ (* Execution of function prologue *)
+ assert (EXEC_PROLOGUE:
+ exec_straight tge (transl_function f)
+ (transl_function f) rs m
+ (transl_code (fn_code f)) rs4 m3).
unfold transl_function at 2.
apply exec_straight_three with rs2 m2 rs3 m2.
- unfold exec_instr. rewrite H. fold sp.
- generalize H0. unfold store_stack. change (Vint (Int.repr 0)) with Vzero.
+ unfold exec_instr. rewrite H0. fold sp.
+ generalize H1. unfold store_stack. change (Vint (Int.repr 0)) with Vzero.
replace (Val.add sp Vzero) with sp. simpl chunk_of_type.
- rewrite (sp_val _ _ _ AG). intro. rewrite H6. clear H6.
+ rewrite (sp_val _ _ _ AG). intro EQ; rewrite EQ; clear EQ.
reflexivity. unfold sp. simpl. rewrite Int.add_zero. reflexivity.
- simpl. replace (rs2 LR) with ra. reflexivity.
+ simpl. change (rs2 LR) with (rs LR). rewrite ATLR. reflexivity.
simpl. unfold store1. rewrite gpr_or_zero_not_zero.
- unfold const_low. replace (rs3 GPR1) with sp. replace (rs3 GPR2) with ra.
- unfold store_stack in H1. simpl chunk_of_type in H1. rewrite H1. reflexivity.
- reflexivity. reflexivity. discriminate.
- reflexivity. reflexivity. reflexivity.
- assert (AT2: transl_code_at_pc rs4#PC f f.(fn_code)).
- change (rs4 PC) with (Val.add (Val.add (Val.add (rs1 PC) Vone) Vone) Vone).
- rewrite EQPC. simpl. constructor. auto.
+ unfold const_low. change (rs3 GPR1) with sp. change (rs3 GPR2) with (parent_ra s).
+ unfold store_stack in H2. simpl chunk_of_type in H2. rewrite H2. reflexivity.
+ discriminate. reflexivity. reflexivity. reflexivity.
+ (* Agreement at end of prologue *)
+ assert (AT4: transl_code_at_pc rs4#PC fb f f.(fn_code)).
+ change (rs4 PC) with (Val.add (Val.add (Val.add (rs PC) Vone) Vone) Vone).
+ rewrite ATPC. simpl. constructor. auto.
eapply code_tail_next_int; auto.
eapply code_tail_next_int; auto.
eapply code_tail_next_int; auto.
- unfold Int.zero. rewrite Int.unsigned_repr.
- rewrite code_tail_zero. unfold transl_function. reflexivity.
- compute. intuition congruence.
+ change (Int.unsigned Int.zero) with 0.
+ unfold transl_function. constructor.
assert (AG2: agree ms sp rs2).
split. reflexivity.
intros. unfold rs2. rewrite nextinstr_inv.
@@ -1107,114 +1275,52 @@ Proof.
auto with ppcgen. auto with ppcgen. auto with ppcgen.
assert (AG4: agree ms sp rs4).
unfold rs4, rs3; auto with ppcgen.
- generalize (H3 rs4 WTF (incl_refl _) AT2 AG4).
- intros [rs5 [AG5 [EXB AT5]]].
- set (rs6 := nextinstr (rs5#GPR2 <- ra)).
- set (rs7 := nextinstr (rs6#LR <- ra)).
- set (rs8 := nextinstr (rs7#GPR1 <- parent)).
- set (rs9 := rs8#PC <- ra).
- assert (exec_straight tge (transl_function f)
- (transl_code (Mreturn :: c)) rs5 m4
- (Pblr :: transl_code c) rs8 (free m4 stk)).
- simpl. apply exec_straight_three with rs6 m4 rs7 m4.
- simpl. unfold load1. rewrite gpr_or_zero_not_zero. unfold const_low.
- unfold load_stack in H5. simpl in H5.
- rewrite <- (sp_val _ _ _ AG5). simpl. rewrite H5.
- reflexivity. discriminate.
- unfold rs7. change ra with rs6#GPR2. reflexivity.
- unfold exec_instr. generalize H4. unfold load_stack.
- replace (Val.add sp (Vint (Int.repr 0))) with sp.
- simpl chunk_of_type. intro. change rs7#GPR1 with rs5#GPR1.
- rewrite <- (sp_val _ _ _ AG5). rewrite H7.
- unfold sp. reflexivity.
- unfold sp. simpl. rewrite Int.add_zero. reflexivity.
- reflexivity. reflexivity. reflexivity.
- exists rs9. split.
- (* agreement *)
- assert (AG7: agree ms' sp rs7).
- unfold rs7, rs6; auto 10 with ppcgen.
- assert (AG8: agree ms' parent rs8).
- split. reflexivity. intros. unfold rs8.
- rewrite nextinstr_inv. rewrite Pregmap.gso.
- elim AG7; auto. auto with ppcgen. auto with ppcgen.
- unfold rs9; auto with ppcgen.
+ left; exists (State rs4 m3); split.
(* execution *)
- split. apply exec_trans with E0 rs4 m3 t.
- eapply exec_straight_steps_1; eauto.
- apply functions_transl; auto.
- apply exec_trans with t rs5 m4 E0. assumption.
- inversion AT5.
- apply exec_trans with E0 rs8 (free m4 stk) E0.
eapply exec_straight_steps_1; eauto.
- apply functions_transl; auto.
- apply exec_one. econstructor.
- change rs8#PC with (Val.add (Val.add (Val.add rs5#PC Vone) Vone) Vone).
- rewrite <- H8. simpl. reflexivity.
- apply functions_transl; eauto.
- assert (code_tail (Int.unsigned (Int.add (Int.add (Int.add ofs Int.one) Int.one) Int.one))
- (transl_function f) = Pblr :: transl_code c).
- eapply code_tail_next_int; auto.
- eapply code_tail_next_int; auto.
- eapply code_tail_next_int; auto.
- rewrite H10. simpl. reflexivity.
- rewrite find_instr_tail. rewrite H13.
- reflexivity.
- reflexivity.
- traceEq. traceEq. traceEq.
- (* LR preservation *)
- change rs9#PC with ra. auto.
+ change (Int.unsigned Int.zero) with 0. constructor.
+ (* match states *)
+ econstructor; eauto with coqlib.
Qed.
-Lemma exec_function_internal_prop:
- forall (f : function) (parent : val) (ms : Mach.regset) (m : mem)
- (t: trace) (ms' : Mach.regset) (m' : mem),
- (forall ra : val,
- Val.has_type ra Tint ->
- exec_function_body ge f parent ra ms m t ms' m') ->
- (forall ra : val, Val.has_type ra Tint ->
- exec_function_body_prop f parent ra ms m t ms' m') ->
- exec_function_prop (Internal f) parent ms m t ms' m'.
+Lemma exec_function_external_prop:
+ forall (s : list stackframe) (fb : block) (ms : Mach.regset)
+ (m : mem) (t0 : trace) (ms' : RegEq.t -> val)
+ (ef : external_function) (args : list val) (res : val),
+ Genv.find_funct_ptr ge fb = Some (External ef) ->
+ event_match ef args t0 res ->
+ Machconcr.extcall_arguments ms m (parent_sp s) (ef_sig ef) args ->
+ ms' = Regmap.set (Conventions.loc_result (ef_sig ef)) res ms ->
+ exec_instr_prop (Machconcr.Callstate s fb ms m)
+ t0 (Machconcr.Returnstate s ms' m).
Proof.
- intros; red; intros.
- inversion WTF. subst f0.
- apply (H0 rs1#LR WTRA rs1 WTRA (refl_equal _) H2 AT AG).
+ intros; red; intros; inv MS.
+ exploit functions_translated; eauto.
+ intros [tf [A B]]. simpl in B. inv B.
+ left; exists (State (rs#(loc_external_result (ef_sig ef)) <- res #PC <- (rs LR))
+ m); split.
+ apply plus_one. eapply exec_step_external; eauto.
+ eapply extcall_arguments_match; eauto.
+ econstructor; eauto.
+ rewrite loc_external_result_match. auto with ppcgen.
Qed.
-Lemma exec_function_external_prop:
- forall (ef : external_function) (parent : val) (args : list val)
- (res : val) (ms1 ms2: Mach.regset) (m : mem)
- (t : trace),
- event_match ef args t res ->
- Mach.extcall_arguments ms1 m parent ef.(ef_sig) args ->
- ms2 = Regmap.set (Conventions.loc_result (ef_sig ef)) res ms1 ->
- exec_function_prop (External ef) parent ms1 m t ms2 m.
+Lemma exec_return_prop:
+ forall (s : list stackframe) (fb : block) (sp ra : val)
+ (c : Mach.code) (ms : Mach.regset) (m : mem),
+ exec_instr_prop (Machconcr.Returnstate (Stackframe fb sp ra c :: s) ms m) E0
+ (Machconcr.State s fb sp c ms m).
Proof.
- intros; red; intros.
- destruct (Genv.find_funct_inv AT) as [b EQ].
- rewrite EQ in AT. rewrite Genv.find_funct_find_funct_ptr in AT.
- exists (rs1#(loc_external_result (ef_sig ef)) <- res #PC <- (rs1 LR)).
- split. rewrite loc_external_result_match. rewrite H1. auto with ppcgen.
- split. apply exec_one. eapply exec_step_external; eauto.
- destruct (functions_translated _ _ AT) as [tf [A B]].
- simpl in B. congruence.
- eapply extcall_arguments_match; eauto.
- reflexivity.
+ intros; red; intros; inv MS. inv STACKS. simpl in *.
+ right. split. omega. split. auto.
+ econstructor; eauto. rewrite ATPC; auto.
Qed.
-(** We then conclude by induction on the structure of the Mach
-execution derivation. *)
-
-Theorem transf_function_correct:
- forall f parent ms m t ms' m',
- Mach.exec_function ge f parent ms m t ms' m' ->
- exec_function_prop f parent ms m t ms' m'.
-Proof
- (Mach.exec_function_ind4 ge
- exec_instr_prop
- exec_instr_prop
- exec_function_body_prop
- exec_function_prop
-
+Theorem transf_instr_correct:
+ forall s1 t s2, Machconcr.step ge s1 t s2 ->
+ exec_instr_prop s1 t s2.
+Proof
+ (Machconcr.step_ind ge exec_instr_prop
exec_Mlabel_prop
exec_Mgetstack_prop
exec_Msetstack_prop
@@ -1223,53 +1329,50 @@ Proof
exec_Mload_prop
exec_Mstore_prop
exec_Mcall_prop
+ exec_Mtailcall_prop
exec_Malloc_prop
exec_Mgoto_prop
exec_Mcond_true_prop
exec_Mcond_false_prop
- exec_refl_prop
- exec_one_prop
- exec_trans_prop
- exec_function_body_prop_
+ exec_Mreturn_prop
exec_function_internal_prop
- exec_function_external_prop).
+ exec_function_external_prop
+ exec_return_prop).
-End PRESERVATION.
+Lemma transf_initial_states:
+ forall st1, Machconcr.initial_state prog st1 ->
+ exists st2, PPC.initial_state tprog st2 /\ match_states st1 st2.
+Proof.
+ intros. inversion H. unfold ge0 in *.
+ econstructor; split.
+ econstructor.
+ replace (symbol_offset (Genv.globalenv tprog) (prog_main tprog) Int.zero)
+ with (Vptr fb Int.zero).
+ rewrite (Genv.init_mem_transf_partial _ _ TRANSF).
+ econstructor; eauto. constructor.
+ split. auto. intros. repeat rewrite Pregmap.gso; auto with ppcgen.
+ unfold symbol_offset.
+ rewrite (transform_partial_program_main _ _ TRANSF).
+ rewrite symbols_preserved. unfold ge; rewrite H0. auto.
+Qed.
+
+Lemma transf_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 -> Machconcr.final_state st1 r -> PPC.final_state st2 r.
+Proof.
+ intros. inv H0. inv H. constructor. auto.
+ rewrite (ireg_val _ _ _ R3 AG) in H1. auto. auto.
+Qed.
Theorem transf_program_correct:
- forall (p: Mach.program) (tp: PPC.program) (t: trace) (r: val),
- wt_program p ->
- transf_program p = Some tp ->
- Mach.exec_program p t r ->
- PPC.exec_program tp t r.
+ forall (beh: program_behavior),
+ Machconcr.exec_program prog beh -> PPC.exec_program tprog beh.
Proof.
- intros.
- destruct H1 as [fptr [f [ms [m [FINDS [FINDF [EX RES]]]]]]].
- assert (WTF: wt_fundef f).
- apply (Genv.find_funct_ptr_prop wt_fundef H FINDF).
- set (ge := Genv.globalenv p) in *.
- set (ms0 := Regmap.init Vundef) in *.
- set (tge := Genv.globalenv tp).
- set (rs0 :=
- (Pregmap.init Vundef) # PC <- (symbol_offset tge tp.(prog_main) Int.zero)
- # LR <- Vzero
- # GPR1 <- (Vptr Mem.nullptr Int.zero)).
- assert (AT: Genv.find_funct ge (rs0 PC) = Some f).
- change (rs0 PC) with (symbol_offset tge tp.(prog_main) Int.zero).
- rewrite (transform_partial_program_main _ _ H0).
- unfold symbol_offset. rewrite (symbols_preserved p tp H0).
- fold ge. rewrite FINDS.
- rewrite Genv.find_funct_find_funct_ptr. exact FINDF.
- assert (AG: agree ms0 (Vptr Mem.nullptr Int.zero) rs0).
- split. reflexivity. intros. unfold rs0.
- repeat (rewrite Pregmap.gso; auto with ppcgen).
- assert (WTRA: Val.has_type (rs0 LR) Tint).
- exact I.
- generalize (transf_function_correct p tp H0 H
- _ _ _ _ _ _ _ EX rs0 WTF AT AG WTRA).
- intros [rs [AG' [EX' RPC]]].
- red. exists rs; exists m.
- split. rewrite (Genv.init_mem_transf_partial _ _ H0). exact EX'.
- split. rewrite RPC. reflexivity. rewrite <- RES.
- change (IR GPR3) with (preg_of R3). elim AG'; auto.
+ unfold Machconcr.exec_program, PPC.exec_program; intros.
+ eapply simulation_star_preservation with (measure := measure); eauto.
+ eexact transf_initial_states.
+ eexact transf_final_states.
+ exact transf_instr_correct.
Qed.
+
+End PRESERVATION.
diff --git a/backend/PPCgenproof1.v b/backend/PPCgenproof1.v
index f9af3c30196c1666b44971e69289e6da56bb03a9..1b432c72c13d24751553b19c111aad082e7356f6 100644
--- a/backend/PPCgenproof1.v
+++ b/backend/PPCgenproof1.v
@@ -11,6 +11,7 @@ Require Import Globalenvs.
Require Import Op.
Require Import Locations.
Require Import Mach.
+Require Import Machconcr.
Require Import Machtyping.
Require Import PPC.
Require Import PPCgen.
@@ -448,7 +449,7 @@ Lemma extcall_args_match:
forall tyl iregl fregl ofs args,
(forall r, In r iregl -> mreg_type r = Tint) ->
(forall r, In r fregl -> mreg_type r = Tfloat) ->
- Mach.extcall_args ms m sp (Conventions.loc_arguments_rec tyl iregl fregl ofs) args ->
+ Machconcr.extcall_args ms m sp (Conventions.loc_arguments_rec tyl iregl fregl ofs) args ->
PPC.extcall_args rs m tyl (List.map ireg_of iregl) (List.map freg_of fregl) (4 * ofs) args.
Proof.
induction tyl; intros.
@@ -478,9 +479,7 @@ Proof.
eapply sp_val; eauto.
change (@nil freg) with (freg_of ## nil).
replace (4 * ofs + 8) with (4 * (ofs + 2)) by omega.
- rewrite list_map_drop2.
apply IHtyl; auto.
- intros. apply H0. apply list_drop2_incl. auto.
(* register *)
inversion H2; subst; clear H2. inversion H8; subst; clear H8.
simpl map. econstructor. eapply freg_val; eauto.
@@ -505,13 +504,13 @@ Ltac ElimOrEq :=
Lemma extcall_arguments_match:
forall ms m sp rs sg args,
agree ms sp rs ->
- Mach.extcall_arguments ms m sp sg args ->
+ Machconcr.extcall_arguments ms m sp sg args ->
PPC.extcall_arguments rs m sg args.
Proof.
- unfold Mach.extcall_arguments, PPC.extcall_arguments; intros.
+ unfold Machconcr.extcall_arguments, PPC.extcall_arguments; intros.
change (extcall_args rs m sg.(sig_args)
(List.map ireg_of Conventions.int_param_regs)
- (List.map freg_of Conventions.float_param_regs) (4 * 6) args).
+ (List.map freg_of Conventions.float_param_regs) (4 * 14) args).
eapply extcall_args_match; eauto.
intro; simpl; ElimOrEq; reflexivity.
intro; simpl; ElimOrEq; reflexivity.
@@ -533,9 +532,11 @@ Variable fn: code.
Inductive exec_straight: code -> regset -> mem ->
code -> regset -> mem -> Prop :=
- | exec_straight_refl:
- forall c rs m,
- exec_straight c rs m c rs m
+ | exec_straight_one:
+ forall i1 c rs1 m1 rs2 m2,
+ exec_instr ge fn i1 rs1 m1 = OK rs2 m2 ->
+ rs2#PC = Val.add rs1#PC Vone ->
+ exec_straight (i1 :: c) rs1 m1 c rs2 m2
| exec_straight_step:
forall i c rs1 m1 rs2 m2 c' rs3 m3,
exec_instr ge fn i rs1 m1 = OK rs2 m2 ->
@@ -549,18 +550,9 @@ Lemma exec_straight_trans:
exec_straight c2 rs2 m2 c3 rs3 m3 ->
exec_straight c1 rs1 m1 c3 rs3 m3.
Proof.
- induction 1. auto.
- intro. apply exec_straight_step with rs2 m2; auto.
-Qed.
-
-Lemma exec_straight_one:
- forall i1 c rs1 m1 rs2 m2,
- exec_instr ge fn i1 rs1 m1 = OK rs2 m2 ->
- rs2#PC = Val.add rs1#PC Vone ->
- exec_straight (i1 :: c) rs1 m1 c rs2 m2.
-Proof.
- intros. apply exec_straight_step with rs2 m2. auto. auto.
- apply exec_straight_refl.
+ induction 1; intros.
+ apply exec_straight_step with rs2 m2; auto.
+ apply exec_straight_step with rs2 m2; auto.
Qed.
Lemma exec_straight_two:
@@ -1182,7 +1174,7 @@ Lemma transl_cond_correct:
forall cond args k ms sp rs m b,
map mreg_type args = type_of_condition cond ->
agree ms sp rs ->
- eval_condition cond (map ms args) = Some b ->
+ eval_condition cond (map ms args) m = Some b ->
exists rs',
exec_straight (transl_cond cond args k) rs m k rs' m
/\ rs'#(reg_of_crbit (fst (crbit_for_cond cond))) =
@@ -1191,7 +1183,7 @@ Lemma transl_cond_correct:
else Val.notbool (Val.of_bool b))
/\ agree ms sp rs'.
Proof.
- intros. rewrite <- (eval_condition_weaken _ _ H1).
+ intros. rewrite <- (eval_condition_weaken _ _ _ H1).
apply transl_cond_correct_aux; auto.
Qed.
@@ -1221,12 +1213,12 @@ Lemma transl_op_correct:
forall op args res k ms sp rs m v,
wt_instr (Mop op args res) ->
agree ms sp rs ->
- eval_operation ge sp op (map ms args) = Some v ->
+ eval_operation ge sp op (map ms args) m = Some v ->
exists rs',
exec_straight (transl_op op args res k) rs m k rs' m
/\ agree (Regmap.set res v ms) sp rs'.
Proof.
- intros. rewrite <- (eval_operation_weaken _ _ _ _ H1). clear H1; clear v.
+ intros. rewrite <- (eval_operation_weaken _ _ _ _ _ H1). clear H1; clear v.
inversion H.
(* Omove *)
simpl. exists (nextinstr (rs#(preg_of res) <- (ms r1))).
@@ -1238,19 +1230,9 @@ Proof.
simpl. unfold preg_of. rewrite <- H2. rewrite H5. reflexivity.
auto with ppcgen.
auto with ppcgen.
- (* Oundef *)
- simpl. exists (nextinstr (rs#(preg_of res) <- Vundef)).
- split. caseEq (mreg_type res); intro.
- apply exec_straight_one. simpl.
- unfold preg_of; rewrite H1. reflexivity.
- auto with ppcgen.
- apply exec_straight_one. simpl.
- unfold preg_of; rewrite H1. reflexivity.
- auto with ppcgen.
- auto with ppcgen.
(* Other instructions *)
- clear H1; clear H2; clear H3.
- destruct op; simpl in H6; injection H6; clear H6; intros;
+ clear H1; clear H2; clear H4.
+ destruct op; simpl in H5; injection H5; clear H5; intros;
TypeInv; simpl; try (TranslOpSimpl).
(* Omove again *)
congruence.
@@ -1283,8 +1265,6 @@ Proof.
exists rs'. split. auto.
apply agree_set_mireg_exten with rs; auto.
rewrite (sp_val ms sp rs). auto. auto.
- (* Oundef again *)
- congruence.
(* Ocast8unsigned *)
exists (nextinstr (rs#(ireg_of res) <- (Val.rolm (ms m0) Int.zero (Int.repr 255)))).
split. apply exec_straight_one. repeat (rewrite (ireg_val ms sp rs)); auto. reflexivity.
diff --git a/backend/PPCgenretaddr.v b/backend/PPCgenretaddr.v
new file mode 100644
index 0000000000000000000000000000000000000000..f2802ecd9635966223a5f1ad2d43045ad0a01f39
--- /dev/null
+++ b/backend/PPCgenretaddr.v
@@ -0,0 +1,176 @@
+(** Predictor for return addresses in generated PPC code.
+
+ The [return_address_offset] predicate defined here is used in the
+ concrete semantics for Mach (module [Machconcr]) to determine the
+ return addresses that are stored in activation records. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Integers.
+Require Import Floats.
+Require Import Values.
+Require Import Mem.
+Require Import Globalenvs.
+Require Import Op.
+Require Import Locations.
+Require Import Mach.
+Require Import PPC.
+Require Import PPCgen.
+
+(** The ``code tail'' of an instruction list [c] is the list of instructions
+ starting at PC [pos]. *)
+
+Inductive code_tail: Z -> code -> code -> Prop :=
+ | code_tail_0: forall c,
+ code_tail 0 c c
+ | code_tail_S: forall pos i c1 c2,
+ code_tail pos c1 c2 ->
+ code_tail (pos + 1) (i :: c1) c2.
+
+Lemma code_tail_pos:
+ forall pos c1 c2, code_tail pos c1 c2 -> pos >= 0.
+Proof.
+ induction 1. omega. omega.
+Qed.
+
+(** Consider a Mach function [f] and a sequence [c] of Mach instructions
+ representing the Mach code that remains to be executed after a
+ function call returns. The predicate [return_address_offset f c ofs]
+ holds if [ofs] is the integer offset of the PPC instruction
+ following the call in the PPC code obtained by translating the
+ code of [f]. Graphically:
+<<
+ Mach function f |--------- Mcall ---------|
+ Mach code c | |--------|
+ | \ \
+ | \ \
+ | \ \
+ PPC code | |--------|
+ PPC function |--------------- Pbl ---------|
+
+ <-------- ofs ------->
+>>
+*)
+
+Inductive return_address_offset: Mach.function -> Mach.code -> int -> Prop :=
+ | return_address_offset_intro:
+ forall c f ofs,
+ code_tail ofs (transl_function f) (transl_code c) ->
+ return_address_offset f c (Int.repr ofs).
+
+(** We now show that such an offset always exists if the Mach code [c]
+ is a suffix of [f.(fn_code)]. This holds because the translation
+ from Mach to PPC is compositional: each Mach instruction becomes
+ zero, one or several PPC instructions, but the order of instructions
+ is preserved. *)
+
+Lemma is_tail_code_tail:
+ forall c1 c2, is_tail c1 c2 -> exists ofs, code_tail ofs c2 c1.
+Proof.
+ induction 1. exists 0; constructor.
+ destruct IHis_tail as [ofs CT]. exists (ofs + 1); constructor; auto.
+Qed.
+
+Hint Resolve is_tail_refl: ppcretaddr.
+
+Ltac IsTail :=
+ auto with ppcretaddr;
+ match goal with
+ | [ |- is_tail _ (_ :: _) ] => constructor; IsTail
+ | [ |- is_tail _ (match ?x with true => _ | false => _ end) ] => destruct x; IsTail
+ | [ |- is_tail _ (match ?x with left _ => _ | right _ => _ end) ] => destruct x; IsTail
+ | [ |- is_tail _ (match ?x with nil => _ | _ :: _ => _ end) ] => destruct x; IsTail
+ | [ |- is_tail _ (match ?x with Tint => _ | Tfloat => _ end) ] => destruct x; IsTail
+ | [ |- is_tail _ (?f _ _ _ _ _ _ ?k) ] => apply is_tail_trans with k; IsTail
+ | [ |- is_tail _ (?f _ _ _ _ _ ?k) ] => apply is_tail_trans with k; IsTail
+ | [ |- is_tail _ (?f _ _ _ _ ?k) ] => apply is_tail_trans with k; IsTail
+ | [ |- is_tail _ (?f _ _ _ ?k) ] => apply is_tail_trans with k; IsTail
+ | [ |- is_tail _ (?f _ _ ?k) ] => apply is_tail_trans with k; IsTail
+ | _ => idtac
+ end.
+
+Lemma loadimm_tail:
+ forall r n k, is_tail k (loadimm r n k).
+Proof. unfold loadimm; intros; IsTail. Qed.
+Hint Resolve loadimm_tail: ppcretaddr.
+
+Lemma addimm_tail:
+ forall r1 r2 n k, is_tail k (addimm r1 r2 n k).
+Proof. unfold addimm, addimm_1, addimm_2; intros; IsTail. Qed.
+Hint Resolve addimm_tail: ppcretaddr.
+
+Lemma andimm_tail:
+ forall r1 r2 n k, is_tail k (andimm r1 r2 n k).
+Proof. unfold andimm; intros; IsTail. Qed.
+Hint Resolve andimm_tail: ppcretaddr.
+
+Lemma orimm_tail:
+ forall r1 r2 n k, is_tail k (orimm r1 r2 n k).
+Proof. unfold orimm; intros; IsTail. Qed.
+Hint Resolve orimm_tail: ppcretaddr.
+
+Lemma xorimm_tail:
+ forall r1 r2 n k, is_tail k (xorimm r1 r2 n k).
+Proof. unfold xorimm; intros; IsTail. Qed.
+Hint Resolve xorimm_tail: ppcretaddr.
+
+Lemma loadind_tail:
+ forall base ofs ty dst k, is_tail k (loadind base ofs ty dst k).
+Proof. unfold loadind; intros; IsTail. Qed.
+Hint Resolve loadind_tail: ppcretaddr.
+
+Lemma storeind_tail:
+ forall src base ofs ty k, is_tail k (storeind src base ofs ty k).
+Proof. unfold storeind; intros; IsTail. Qed.
+Hint Resolve storeind_tail: ppcretaddr.
+
+Lemma floatcomp_tail:
+ forall cmp r1 r2 k, is_tail k (floatcomp cmp r1 r2 k).
+Proof. unfold floatcomp; intros; destruct cmp; IsTail. Qed.
+Hint Resolve floatcomp_tail: ppcretaddr.
+
+Lemma transl_cond_tail:
+ forall cond args k, is_tail k (transl_cond cond args k).
+Proof. unfold transl_cond; intros; destruct cond; IsTail. Qed.
+Hint Resolve transl_cond_tail: ppcretaddr.
+
+Lemma transl_op_tail:
+ forall op args r k, is_tail k (transl_op op args r k).
+Proof. unfold transl_op; intros; destruct op; IsTail. Qed.
+Hint Resolve transl_op_tail: ppcretaddr.
+
+Lemma transl_load_store_tail:
+ forall mk1 mk2 addr args k,
+ is_tail k (transl_load_store mk1 mk2 addr args k).
+Proof. unfold transl_load_store; intros; destruct addr; IsTail. Qed.
+Hint Resolve transl_load_store_tail: ppcretaddr.
+
+Lemma transl_instr_tail:
+ forall i k, is_tail k (transl_instr i k).
+Proof.
+ unfold transl_instr; intros; destruct i; IsTail.
+ destruct m; IsTail.
+ destruct m; IsTail.
+ destruct s0; IsTail.
+ destruct s0; IsTail.
+Qed.
+Hint Resolve transl_instr_tail: ppcretaddr.
+
+Lemma transl_code_tail:
+ forall c1 c2, is_tail c1 c2 -> is_tail (transl_code c1) (transl_code c2).
+Proof.
+ induction 1; simpl. constructor. eapply is_tail_trans; eauto with ppcretaddr.
+Qed.
+
+Lemma return_address_exists:
+ forall f c, is_tail c f.(fn_code) ->
+ exists ra, return_address_offset f c ra.
+Proof.
+ intros. assert (is_tail (transl_code c) (transl_function f)).
+ unfold transl_function. IsTail. apply transl_code_tail; auto.
+ destruct (is_tail_code_tail _ _ H0) as [ofs A].
+ exists (Int.repr ofs). constructor. auto.
+Qed.
+
+
diff --git a/backend/Parallelmove.v b/backend/Parallelmove.v
index b2ec930bf983c100b827c928449a68eae927d3b9..3d77b57ae8aac9d46d2b0f4543dd5104a97ffb55 100644
--- a/backend/Parallelmove.v
+++ b/backend/Parallelmove.v
@@ -1,3 +1,14 @@
+(** Translation of parallel moves into sequences of individual moves.
+
+ In this file, we adapt the generic "parallel move" algorithm
+ (developed and proved correct in module [Parmov]) to the idiosyncraties
+ of the [LTLin] and [Linear] intermediate languages. While the generic
+ algorithm assumes that registers never overlap, the locations
+ used in [LTLin] and [Linear] can overlap, and assigning one location
+ can set the values of other, overlapping locations to [Vundef].
+ We address this issue in the remainder of this file.
+*)
+
Require Import Coqlib.
Require Parmov.
Require Import Values.
@@ -6,16 +17,28 @@ Require Import AST.
Require Import Locations.
Require Import Conventions.
+(** * Instantiating the generic parallel move algorithm *)
+
+(** The temporary location to use for a move is determined
+ by the type of the data being moved: register [IT2] for an
+ integer datum, and register [FT2] for a floating-point datum. *)
+
Definition temp_for (l: loc) : loc :=
match Loc.type l with Tint => R IT2 | Tfloat => R FT2 end.
Definition parmove (srcs dsts: list loc) :=
- Parmov.parmove2 loc temp_for Loc.eq srcs dsts.
+ Parmov.parmove2 loc Loc.eq temp_for srcs dsts.
Definition moves := (list (loc * loc))%type.
+(** [exec_seq m] gives semantics to a sequence of elementary moves.
+ This semantics ignores the possibility of overlap: only the
+ target locations are updated, but the locations they
+ overlap with are not set to [Vundef]. See [effect_seqmove] below
+ for a semantics that accounts for overlaps. *)
+
Definition exec_seq (m: moves) (e: Locmap.t) : Locmap.t :=
- Parmov.exec_seq loc val Loc.eq m e.
+ Parmov.exec_seq loc Loc.eq val m e.
Lemma temp_for_charact:
forall l, temp_for l = R IT2 \/ temp_for l = R FT2.
@@ -52,6 +75,12 @@ Proof.
apply Loc.notin_not_in; auto. auto.
Qed.
+(** Instantiating the theorems proved in [Parmov], we obtain
+ the following properties of semantic correctness and well-typedness
+ of the generated sequence of moves. Note that the semantic
+ correctness result is stated in terms of the [exec_seq] semantics,
+ and therefore does not account for overlap between locations. *)
+
Lemma parmove_prop_1:
forall srcs dsts,
List.length srcs = List.length dsts ->
@@ -69,8 +98,8 @@ Proof.
intros. apply disjoint_temp_not_temp. apply Loc.disjoint_notin with srcs; auto.
assert (NTD: forall r, In r dsts -> Parmov.is_not_temp loc temp_for r).
intros. apply disjoint_temp_not_temp. apply Loc.disjoint_notin with dsts; auto.
- generalize (Parmov.parmove2_correctness loc temp_for val Loc.eq srcs dsts H NR NTS NTD e).
- change (Parmov.exec_seq loc val Loc.eq (Parmov.parmove2 loc temp_for Loc.eq srcs dsts) e) with e'.
+ generalize (Parmov.parmove2_correctness loc Loc.eq temp_for val srcs dsts H NR NTS NTD e).
+ change (Parmov.exec_seq loc Loc.eq val (Parmov.parmove2 loc Loc.eq temp_for srcs dsts) e) with e'.
intros [A B].
split. auto. intros. apply B. auto. rewrite is_not_temp_charact; auto.
Qed.
@@ -97,7 +126,7 @@ Proof.
tauto.
right. apply temp_for_charact.
intros. apply H.
- apply (Parmov.parmove2_wf_moves loc temp_for Loc.eq srcs dsts s d H0).
+ apply (Parmov.parmove2_wf_moves loc Loc.eq temp_for srcs dsts s d H0).
Qed.
Lemma loc_type_temp_for:
@@ -134,11 +163,21 @@ Proof.
rewrite loc_type_temp_for; auto.
rewrite loc_type_temp_for; auto.
intros. apply H.
- apply (Parmov.parmove2_wf_moves loc temp_for Loc.eq srcs dsts s d H0).
+ apply (Parmov.parmove2_wf_moves loc Loc.eq temp_for srcs dsts s d H0).
Qed.
+(** * Accounting for overlap between locations *)
+
Section EQUIVALENCE.
+(** We now prove the correctness of the generated sequence of elementary
+ moves, accounting for possible overlap between locations.
+ The proof is conducted under the following hypotheses: there must
+ be no partial overlap between
+- two distinct destinations (hypothesis [NOREPET]);
+- a source location and a destination location (hypothesis [NO_OVERLAP]).
+*)
+
Variables srcs dsts: list loc.
Hypothesis LENGTH: List.length srcs = List.length dsts.
Hypothesis NOREPET: Loc.norepet dsts.
@@ -146,9 +185,16 @@ Hypothesis NO_OVERLAP: Loc.no_overlap srcs dsts.
Hypothesis NO_SRCS_TEMP: Loc.disjoint srcs temporaries.
Hypothesis NO_DSTS_TEMP: Loc.disjoint dsts temporaries.
+(** [no_overlap_dests l] holds if location [l] does not partially overlap
+ a destination location: either it is identical to one of the
+ destinations, or it is disjoint from all destinations. *)
+
Definition no_overlap_dests (l: loc) : Prop :=
forall d, In d dsts -> l = d \/ Loc.diff l d.
+(** We show that [no_overlap_dests] holds for any destination location
+ and for any source location. *)
+
Lemma dests_no_overlap_dests:
forall l, In l dsts -> no_overlap_dests l.
Proof.
@@ -201,10 +247,19 @@ Proof.
elim H2; intro; subst d; auto.
Qed.
+(** [locmap_equiv e1 e2] holds if the location maps [e1] and [e2]
+ assign the same values to all locations except temporaries [IT1], [FT1]
+ and except locations that partially overlap a destination. *)
+
Definition locmap_equiv (e1 e2: Locmap.t): Prop :=
forall l,
no_overlap_dests l -> Loc.diff l (R IT1) -> Loc.diff l (R FT1) -> e2 l = e1 l.
+(** The following predicates characterize the effect of one move
+ move ([effect_move]) and of a sequence of elementary moves
+ ([effect_seqmove]). We allow the code generated for one move
+ to use the temporaries [IT1] and [FT1] in any way it needs. *)
+
Definition effect_move (src dst: loc) (e e': Locmap.t): Prop :=
e' dst = e src /\
forall l, Loc.diff l dst -> Loc.diff l (R IT1) -> Loc.diff l (R FT1) -> e' l = e l.
@@ -217,12 +272,18 @@ Inductive effect_seqmove: list (loc * loc) -> Locmap.t -> Locmap.t -> Prop :=
effect_seqmove m e2 e3 ->
effect_seqmove ((s, d) :: m) e1 e3.
+(** The following crucial lemma shows that [locmap_equiv] is preserved
+ by executing one move [d <- s], once using the [effect_move]
+ predicate that accounts for partial overlap and the use of
+ temporaries [IT1], [FT1], or via the [Parmov.update] function that
+ does not account for any of these. *)
+
Lemma effect_move_equiv:
forall s d e1 e2 e1',
(In s srcs \/ s = R IT2 \/ s = R FT2) ->
(In d dsts \/ d = R IT2 \/ d = R FT2) ->
locmap_equiv e1 e2 -> effect_move s d e1 e1' ->
- locmap_equiv e1' (Parmov.update loc val Loc.eq d (e2 s) e2).
+ locmap_equiv e1' (Parmov.update loc Loc.eq val d (e2 s) e2).
Proof.
intros. destruct H2. red; intros.
unfold Parmov.update. destruct (Loc.eq l d).
@@ -231,6 +292,9 @@ Proof.
rewrite H3; auto. apply dest_noteq_diff; auto.
Qed.
+(** We then extend the previous lemma to a sequence [mu] of elementary moves.
+*)
+
Lemma effect_seqmove_equiv:
forall mu e1 e1',
effect_seqmove mu e1 e1' ->
@@ -249,6 +313,13 @@ Proof.
eapply effect_move_equiv; eauto.
Qed.
+(** Here is the main result in this file: executing the sequence
+ of moves returned by the [parmove] function results in the
+ desired state for locations: the final values of destination locations
+ are the initial values of source locations, and all locations
+ that are disjoint from the temporaries and the destinations
+ keep their initial values. *)
+
Lemma effect_parmove:
forall e e',
effect_seqmove (parmove srcs dsts) e e' ->
diff --git a/backend/RTL.v b/backend/RTL.v
index 8b46a7dbcabe99b93b24048375a651519922a8ea..747199774609937444cb7db5410e108fee416172 100644
--- a/backend/RTL.v
+++ b/backend/RTL.v
@@ -1,10 +1,9 @@
(** The RTL intermediate language: abstract syntax and semantics.
- RTL (``Register Transfer Language'' is the first intermediate language
- after Cminor.
+ RTL stands for "Register Transfer Language". This is the first
+ intermediate language after Cminor and CminorSel.
*)
-(*Require Import Relations.*)
Require Import Coqlib.
Require Import Maps.
Require Import AST.
@@ -13,6 +12,7 @@ Require Import Values.
Require Import Events.
Require Import Mem.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Op.
Require Import Registers.
@@ -55,6 +55,7 @@ Inductive instruction: Set :=
function name), giving it the values of registers [args]
as arguments. It stores the return value in [dest] and branches
to [succ]. *)
+ | Itailcall: signature -> reg + ident -> list reg -> instruction
| Ialloc: reg -> reg -> node -> instruction
(** [Ialloc arg dest succ] allocates a fresh block of size
the contents of register [arg], stores a pointer to this
@@ -111,6 +112,52 @@ Fixpoint init_regs (vl: list val) (rl: list reg) {struct rl} : regset :=
| _, _ => Regmap.init Vundef
end.
+Inductive stackframe : Set :=
+ | Stackframe:
+ forall (res: reg) (c: code) (sp: val) (pc: node) (rs: regset),
+ stackframe.
+
+Inductive state : Set :=
+ | State:
+ forall (stack: list stackframe) (c: code) (sp: val) (pc: node)
+ (rs: regset) (m: mem), state
+ | Callstate:
+ forall (stack: list stackframe) (f: fundef) (args: list val) (m: mem),
+ state
+ | Returnstate:
+ forall (stack: list stackframe) (v: val) (m: mem),
+ state.
+
+(** The dynamic semantics of RTL is given in small-step style, as a
+ set of transitions between states. A state captures the current
+ point in the execution. Three kinds of states appear in the transitions:
+
+- [State cs c sp pc rs m] describes an execution point within a function.
+ [c] is the code for the current function (a CFG).
+ [sp] is the pointer to the stack block for its current activation
+ (as in Cminor).
+ [pc] is the current program point (CFG node) within the code [c].
+ [rs] gives the current values for the pseudo-registers.
+ [m] is the current memory state.
+- [Callstate cs f args m] is an intermediate state that appears during
+ function calls.
+ [f] is the function definition that we are calling.
+ [args] (a list of values) are the arguments for this call.
+ [m] is the current memory state.
+- [Returnstate cs v m] is an intermediate state that appears when a
+ function terminates and returns to its caller.
+ [v] is the return value and [m] the current memory state.
+
+In all three kinds of states, the [cs] parameter represents the call stack.
+It is a list of frames [Stackframe res c sp pc rs]. Each frame represents
+a function call in progress.
+[res] is the pseudo-register that will receive the result of the call.
+[c] is the code of the calling function.
+[sp] is its stack pointer.
+[pc] is the program point for the instruction that follows the call.
+[rs] is the state of registers in the calling function.
+*)
+
Section RELSEM.
Variable ge: genv.
@@ -126,194 +173,142 @@ Definition find_function
end
end.
-(** The dynamic semantics of RTL is a combination of small-step (transition)
- semantics and big-step semantics. Execution of an instruction performs
- a single transition to the next instruction (small-step), except if
- the instruction is a function call. In this case, the whole body of
- the called function is executed at once and the transition terminates
- on the instruction immediately following the call in the caller function.
- Such ``mixed-step'' semantics is convenient for reasoning over
- intra-procedural analyses and transformations. It also dispenses us
- from making the call stack explicit in the semantics.
-
- The semantics is organized in three mutually inductive predicates.
- The first is [exec_instr ge c sp pc rs m pc' rs' m']. [ge] is the
- global environment (see module [Genv]), [c] the CFG for the current
- function, and [sp] the pointer to the stack block for its
- current activation (as in Cminor). [pc], [rs] and [m] is the
- initial state of the transition: program point (CFG node) [pc],
- register state (mapping of pseudo-registers to values) [rs],
- and memory state [m]. The final state is [pc'], [rs'] and [m']. *)
-
-Inductive exec_instr: code -> val ->
- node -> regset -> mem -> trace ->
- node -> regset -> mem -> Prop :=
+(** The transitions are presented as an inductive predicate
+ [step ge st1 t st2], where [ge] is the global environment,
+ [st1] the initial state, [st2] the final state, and [t] the trace
+ of system calls performed during this transition. *)
+
+Inductive step: state -> trace -> state -> Prop :=
| exec_Inop:
- forall c sp pc rs m pc',
+ forall s c sp pc rs m pc',
c!pc = Some(Inop pc') ->
- exec_instr c sp pc rs m E0 pc' rs m
+ step (State s c sp pc rs m)
+ E0 (State s c sp pc' rs m)
| exec_Iop:
- forall c sp pc rs m op args res pc' v,
+ forall s c sp pc rs m op args res pc' v,
c!pc = Some(Iop op args res pc') ->
- eval_operation ge sp op rs##args = Some v ->
- exec_instr c sp pc rs m E0 pc' (rs#res <- v) m
+ eval_operation ge sp op rs##args m = Some v ->
+ step (State s c sp pc rs m)
+ E0 (State s c sp pc' (rs#res <- v) m)
| exec_Iload:
- forall c sp pc rs m chunk addr args dst pc' a v,
+ forall s c sp pc rs m chunk addr args dst pc' a v,
c!pc = Some(Iload chunk addr args dst pc') ->
eval_addressing ge sp addr rs##args = Some a ->
Mem.loadv chunk m a = Some v ->
- exec_instr c sp pc rs m E0 pc' (rs#dst <- v) m
+ step (State s c sp pc rs m)
+ E0 (State s c sp pc' (rs#dst <- v) m)
| exec_Istore:
- forall c sp pc rs m chunk addr args src pc' a m',
+ forall s c sp pc rs m chunk addr args src pc' a m',
c!pc = Some(Istore chunk addr args src pc') ->
eval_addressing ge sp addr rs##args = Some a ->
Mem.storev chunk m a rs#src = Some m' ->
- exec_instr c sp pc rs m E0 pc' rs m'
+ step (State s c sp pc rs m)
+ E0 (State s c sp pc' rs m')
| exec_Icall:
- forall c sp pc rs m sig ros args res pc' f vres m' t,
+ forall s c sp pc rs m sig ros args res pc' f,
c!pc = Some(Icall sig ros args res pc') ->
find_function ros rs = Some f ->
funsig f = sig ->
- exec_function f rs##args m t vres m' ->
- exec_instr c sp pc rs m t pc' (rs#res <- vres) m'
+ step (State s c sp pc rs m)
+ E0 (Callstate (Stackframe res c sp pc' rs :: s) f rs##args m)
+ | exec_Itailcall:
+ forall s c stk pc rs m sig ros args f,
+ c!pc = Some(Itailcall sig ros args) ->
+ find_function ros rs = Some f ->
+ funsig f = sig ->
+ step (State s c (Vptr stk Int.zero) pc rs m)
+ E0 (Callstate s f rs##args (Mem.free m stk))
| exec_Ialloc:
- forall c sp pc rs m pc' arg res sz m' b,
+ forall s c sp pc rs m pc' arg res sz m' b,
c!pc = Some(Ialloc arg res pc') ->
rs#arg = Vint sz ->
Mem.alloc m 0 (Int.signed sz) = (m', b) ->
- exec_instr c sp pc rs m E0 pc' (rs#res <- (Vptr b Int.zero)) m'
+ step (State s c sp pc rs m)
+ E0 (State s c sp pc' (rs#res <- (Vptr b Int.zero)) m')
| exec_Icond_true:
- forall c sp pc rs m cond args ifso ifnot,
+ forall s c sp pc rs m cond args ifso ifnot,
c!pc = Some(Icond cond args ifso ifnot) ->
- eval_condition cond rs##args = Some true ->
- exec_instr c sp pc rs m E0 ifso rs m
+ eval_condition cond rs##args m = Some true ->
+ step (State s c sp pc rs m)
+ E0 (State s c sp ifso rs m)
| exec_Icond_false:
- forall c sp pc rs m cond args ifso ifnot,
+ forall s c sp pc rs m cond args ifso ifnot,
c!pc = Some(Icond cond args ifso ifnot) ->
- eval_condition cond rs##args = Some false ->
- exec_instr c sp pc rs m E0 ifnot rs m
-
-(** [exec_instrs ge c sp pc rs m pc' rs' m'] is the reflexive
- transitive closure of [exec_instr]. It corresponds to the execution
- of zero, one or finitely many transitions. *)
-
-with exec_instrs: code -> val ->
- node -> regset -> mem -> trace ->
- node -> regset -> mem -> Prop :=
- | exec_refl:
- forall c sp pc rs m,
- exec_instrs c sp pc rs m E0 pc rs m
- | exec_one:
- forall c sp pc rs m t pc' rs' m',
- exec_instr c sp pc rs m t pc' rs' m' ->
- exec_instrs c sp pc rs m t pc' rs' m'
- | exec_trans:
- forall c sp pc1 rs1 m1 t1 pc2 rs2 m2 t2 pc3 rs3 m3 t3,
- exec_instrs c sp pc1 rs1 m1 t1 pc2 rs2 m2 ->
- exec_instrs c sp pc2 rs2 m2 t2 pc3 rs3 m3 ->
- t3 = t1 ** t2 ->
- exec_instrs c sp pc1 rs1 m1 t3 pc3 rs3 m3
-
-(** [exec_function ge f args m res m'] executes a function application.
- [f] is the called function, [args] the values of its arguments,
- and [m] the memory state at the beginning of the call. [res] is
- the returned value: the value of [r] if the function terminates with
- a [Ireturn (Some r)], or [Vundef] if it terminates with [Ireturn None].
- Evaluation proceeds by executing transitions from the function's entry
- point to the first [Ireturn] instruction encountered. It is preceeded
- by the allocation of the stack activation block and the binding
- of register parameters to the provided arguments.
- (Non-parameter registers are initialized to [Vundef].) Before returning,
- the stack activation block is freed. *)
-
-with exec_function: fundef -> list val -> mem -> trace ->
- val -> mem -> Prop :=
- | exec_funct_internal:
- forall f m m1 stk args t pc rs m2 or vres,
- Mem.alloc m 0 f.(fn_stacksize) = (m1, stk) ->
- exec_instrs f.(fn_code) (Vptr stk Int.zero)
- f.(fn_entrypoint) (init_regs args f.(fn_params)) m1
- t pc rs m2 ->
- f.(fn_code)!pc = Some(Ireturn or) ->
- vres = regmap_optget or Vundef rs ->
- exec_function (Internal f) args m t vres (Mem.free m2 stk)
- | exec_funct_external:
- forall ef args m t res,
+ eval_condition cond rs##args m = Some false ->
+ step (State s c sp pc rs m)
+ E0 (State s c sp ifnot rs m)
+ | exec_Ireturn:
+ forall s c stk pc rs m or,
+ c!pc = Some(Ireturn or) ->
+ step (State s c (Vptr stk Int.zero) pc rs m)
+ E0 (Returnstate s (regmap_optget or Vundef rs) (Mem.free m stk))
+ | exec_function_internal:
+ forall s f args m m' stk,
+ Mem.alloc m 0 f.(fn_stacksize) = (m', stk) ->
+ step (Callstate s (Internal f) args m)
+ E0 (State s
+ f.(fn_code)
+ (Vptr stk Int.zero)
+ f.(fn_entrypoint)
+ (init_regs args f.(fn_params))
+ m')
+ | exec_function_external:
+ forall s ef args res t m,
event_match ef args t res ->
- exec_function (External ef) args m t res m.
-
-Scheme exec_instr_ind_3 := Minimality for exec_instr Sort Prop
- with exec_instrs_ind_3 := Minimality for exec_instrs Sort Prop
- with exec_function_ind_3 := Minimality for exec_function Sort Prop.
-
-(** Some derived execution rules. *)
-
-Lemma exec_step:
- forall c sp pc1 rs1 m1 t1 pc2 rs2 m2 t2 pc3 rs3 m3 t3,
- exec_instr c sp pc1 rs1 m1 t1 pc2 rs2 m2 ->
- exec_instrs c sp pc2 rs2 m2 t2 pc3 rs3 m3 ->
- t3 = t1 ** t2 ->
- exec_instrs c sp pc1 rs1 m1 t3 pc3 rs3 m3.
-Proof.
- intros. eapply exec_trans. apply exec_one. eauto. eauto. auto.
-Qed.
+ step (Callstate s (External ef) args m)
+ t (Returnstate s res m)
+ | exec_return:
+ forall res c sp pc rs s vres m,
+ step (Returnstate (Stackframe res c sp pc rs :: s) vres m)
+ E0 (State s c sp pc (rs#res <- vres) m).
Lemma exec_Iop':
- forall c sp pc rs m op args res pc' rs' v,
+ forall s c sp pc rs m op args res pc' rs' v,
c!pc = Some(Iop op args res pc') ->
- eval_operation ge sp op rs##args = Some v ->
+ eval_operation ge sp op rs##args m = Some v ->
rs' = (rs#res <- v) ->
- exec_instr c sp pc rs m E0 pc' rs' m.
+ step (State s c sp pc rs m)
+ E0 (State s c sp pc' rs' m).
Proof.
intros. subst rs'. eapply exec_Iop; eauto.
Qed.
Lemma exec_Iload':
- forall c sp pc rs m chunk addr args dst pc' rs' a v,
+ forall s c sp pc rs m chunk addr args dst pc' rs' a v,
c!pc = Some(Iload chunk addr args dst pc') ->
eval_addressing ge sp addr rs##args = Some a ->
Mem.loadv chunk m a = Some v ->
rs' = (rs#dst <- v) ->
- exec_instr c sp pc rs m E0 pc' rs' m.
+ step (State s c sp pc rs m)
+ E0 (State s c sp pc' rs' m).
Proof.
intros. subst rs'. eapply exec_Iload; eauto.
Qed.
-(** If a transition can take place from [pc], the instruction at [pc]
- is defined in the CFG. *)
+End RELSEM.
-Lemma exec_instr_present:
- forall c sp pc rs m t pc' rs' m',
- exec_instr c sp pc rs m t pc' rs' m' ->
- c!pc <> None.
-Proof.
- induction 1; congruence.
-Qed.
+(** Execution of whole programs are described as sequences of transitions
+ from an initial state to a final state. An initial state is a [Callstate]
+ corresponding to the invocation of the ``main'' function of the program
+ without arguments and with an empty call stack. *)
-Lemma exec_instrs_present:
- forall c sp pc rs m t pc' rs' m',
- exec_instrs c sp pc rs m t pc' rs' m' ->
- c!pc' <> None -> c!pc <> None.
-Proof.
- induction 1; intros.
- auto.
- eapply exec_instr_present; eauto.
- eauto.
-Qed.
+Inductive initial_state (p: program): state -> Prop :=
+ | initial_state_intro: forall b f,
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ Genv.find_symbol ge p.(prog_main) = Some b ->
+ Genv.find_funct_ptr ge b = Some f ->
+ funsig f = mksignature nil (Some Tint) ->
+ initial_state p (Callstate nil f nil m0).
-End RELSEM.
+(** A final state is a [Returnstate] with an empty call stack. *)
-(** Execution of whole programs. As in Cminor, we call the ``main'' function
- with no arguments and observe its return value. *)
+Inductive final_state: state -> int -> Prop :=
+ | final_state_intro: forall r m,
+ final_state (Returnstate nil (Vint r) m) r.
-Definition exec_program (p: program) (t: trace) (r: val) : Prop :=
- let ge := Genv.globalenv p in
- let m0 := Genv.init_mem p in
- exists b, exists f, exists m,
- Genv.find_symbol ge p.(prog_main) = Some b /\
- Genv.find_funct_ptr ge b = Some f /\
- funsig f = mksignature nil (Some Tint) /\
- exec_function ge f nil m0 t r m.
+Definition exec_program (p: program) (beh: program_behavior) : Prop :=
+ program_behaves step (initial_state p) final_state (Genv.globalenv p) beh.
(** * Operations on RTL abstract syntax *)
@@ -330,21 +325,13 @@ Definition successors (f: function) (pc: node) : list node :=
| Iload chunk addr args dst s => s :: nil
| Istore chunk addr args src s => s :: nil
| Icall sig ros args res s => s :: nil
+ | Itailcall sig ros args => nil
| Ialloc arg res s => s :: nil
| Icond cond args ifso ifnot => ifso :: ifnot :: nil
| Ireturn optarg => nil
end
end.
-Lemma successors_correct:
- forall ge f sp pc rs m t pc' rs' m',
- exec_instr ge f.(fn_code) sp pc rs m t pc' rs' m' ->
- In pc' (successors f pc).
-Proof.
- intros ge f. unfold successors. generalize (fn_code f).
- induction 1; rewrite H; simpl; tauto.
-Qed.
-
(** Transformation of a RTL function instruction by instruction.
This applies a given transformation function to all instructions
of a function and constructs a transformed function from that. *)
diff --git a/backend/RTLbigstep.v b/backend/RTLbigstep.v
new file mode 100644
index 0000000000000000000000000000000000000000..0ad6e68a12fb9c9acb7b8c9bc3062cdc60bad4ce
--- /dev/null
+++ b/backend/RTLbigstep.v
@@ -0,0 +1,400 @@
+(** An alternate, mixed-step semantics for the RTL intermediate language. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Integers.
+Require Import Values.
+Require Import Events.
+Require Import Mem.
+Require Import Globalenvs.
+Require Import Smallstep.
+Require Import Op.
+Require Import Registers.
+Require Import RTL.
+
+Section BIGSTEP.
+
+Variable ge: genv.
+
+(** The dynamic semantics of RTL is a combination of small-step (transition)
+ semantics and big-step semantics. Execution of an instruction performs
+ a single transition to the next instruction (small-step), except if
+ the instruction is a function call. In this case, the whole body of
+ the called function is executed at once and the transition terminates
+ on the instruction immediately following the call in the caller function.
+ Such ``mixed-step'' semantics is convenient for reasoning over
+ intra-procedural analyses and transformations. It also dispenses us
+ from making the call stack explicit in the semantics.
+
+ The semantics is organized in three mutually inductive predicates.
+ The first is [exec_instr ge c sp pc rs m pc' rs' m']. [ge] is the
+ global environment (see module [Genv]), [c] the CFG for the current
+ function, and [sp] the pointer to the stack block for its
+ current activation (as in Cminor). [pc], [rs] and [m] is the
+ initial state of the transition: program point (CFG node) [pc],
+ register state (mapping of pseudo-registers to values) [rs],
+ and memory state [m]. The final state is [pc'], [rs'] and [m']. *)
+
+Inductive exec_instr: code -> val ->
+ node -> regset -> mem -> trace ->
+ node -> regset -> mem -> Prop :=
+ | exec_Inop:
+ forall c sp pc rs m pc',
+ c!pc = Some(Inop pc') ->
+ exec_instr c sp pc rs m E0 pc' rs m
+ | exec_Iop:
+ forall c sp pc rs m op args res pc' v,
+ c!pc = Some(Iop op args res pc') ->
+ eval_operation ge sp op rs##args m = Some v ->
+ exec_instr c sp pc rs m E0 pc' (rs#res <- v) m
+ | exec_Iload:
+ forall c sp pc rs m chunk addr args dst pc' a v,
+ c!pc = Some(Iload chunk addr args dst pc') ->
+ eval_addressing ge sp addr rs##args = Some a ->
+ Mem.loadv chunk m a = Some v ->
+ exec_instr c sp pc rs m E0 pc' (rs#dst <- v) m
+ | exec_Istore:
+ forall c sp pc rs m chunk addr args src pc' a m',
+ c!pc = Some(Istore chunk addr args src pc') ->
+ eval_addressing ge sp addr rs##args = Some a ->
+ Mem.storev chunk m a rs#src = Some m' ->
+ exec_instr c sp pc rs m E0 pc' rs m'
+ | exec_Icall:
+ forall c sp pc rs m sig ros args res pc' f vres m' t,
+ c!pc = Some(Icall sig ros args res pc') ->
+ find_function ge ros rs = Some f ->
+ funsig f = sig ->
+ exec_function f rs##args m t vres m' ->
+ exec_instr c sp pc rs m t pc' (rs#res <- vres) m'
+ | exec_Ialloc:
+ forall c sp pc rs m pc' arg res sz m' b,
+ c!pc = Some(Ialloc arg res pc') ->
+ rs#arg = Vint sz ->
+ Mem.alloc m 0 (Int.signed sz) = (m', b) ->
+ exec_instr c sp pc rs m E0 pc' (rs#res <- (Vptr b Int.zero)) m'
+ | exec_Icond_true:
+ forall c sp pc rs m cond args ifso ifnot,
+ c!pc = Some(Icond cond args ifso ifnot) ->
+ eval_condition cond rs##args m = Some true ->
+ exec_instr c sp pc rs m E0 ifso rs m
+ | exec_Icond_false:
+ forall c sp pc rs m cond args ifso ifnot,
+ c!pc = Some(Icond cond args ifso ifnot) ->
+ eval_condition cond rs##args m = Some false ->
+ exec_instr c sp pc rs m E0 ifnot rs m
+
+(** [exec_body ge c sp pc rs m res m'] repeatedly executes
+ instructions starting at [pc] in [c], until it
+ reaches a return or tailcall instruction. It performs
+ that instruction and sets [res] to the return value
+ and [m'] to the final memory state. *)
+
+with exec_body: code -> val ->
+ node -> regset -> mem -> trace ->
+ val -> mem -> Prop :=
+ | exec_body_step: forall c sp pc rs m t1 pc1 rs1 m1 t2 t res m2,
+ exec_instr c sp pc rs m t1 pc1 rs1 m1 ->
+ exec_body c sp pc1 rs1 m1 t2 res m2 ->
+ t = t1 ** t2 ->
+ exec_body c sp pc rs m t res m2
+ | exec_Ireturn: forall c stk pc rs m or res,
+ c!pc = Some(Ireturn or) ->
+ res = regmap_optget or Vundef rs ->
+ exec_body c (Vptr stk Int.zero) pc rs m E0 res (Mem.free m stk)
+ | exec_Itailcall: forall c stk pc rs m sig ros args f t res m',
+ c!pc = Some(Itailcall sig ros args) ->
+ find_function ge ros rs = Some f ->
+ funsig f = sig ->
+ exec_function f rs##args (Mem.free m stk) t res m' ->
+ exec_body c (Vptr stk Int.zero) pc rs m t res m'
+
+(** [exec_function ge f args m res m'] executes a function application.
+ [f] is the called function, [args] the values of its arguments,
+ and [m] the memory state at the beginning of the call. [res] is
+ the returned value: the value of [r] if the function terminates with
+ a [Ireturn (Some r)], or [Vundef] if it terminates with [Ireturn None].
+ Evaluation proceeds by executing transitions from the function's entry
+ point to the first [Ireturn] instruction encountered. It is preceeded
+ by the allocation of the stack activation block and the binding
+ of register parameters to the provided arguments.
+ (Non-parameter registers are initialized to [Vundef].) Before returning,
+ the stack activation block is freed. *)
+
+with exec_function: fundef -> list val -> mem -> trace ->
+ val -> mem -> Prop :=
+ | exec_funct_internal:
+ forall f m m1 stk args t m2 vres,
+ Mem.alloc m 0 f.(fn_stacksize) = (m1, stk) ->
+ exec_body f.(fn_code) (Vptr stk Int.zero)
+ f.(fn_entrypoint) (init_regs args f.(fn_params)) m1
+ t vres m2 ->
+ exec_function (Internal f) args m t vres m2
+ | exec_funct_external:
+ forall ef args m t res,
+ event_match ef args t res ->
+ exec_function (External ef) args m t res m.
+
+Scheme exec_instr_ind_3 := Minimality for exec_instr Sort Prop
+ with exec_body_ind_3 := Minimality for exec_body Sort Prop
+ with exec_function_ind_3 := Minimality for exec_function Sort Prop.
+
+(** The reflexive transitive closure of [exec_instr]. *)
+
+Inductive exec_instrs: code -> val ->
+ node -> regset -> mem -> trace ->
+ node -> regset -> mem -> Prop :=
+ | exec_refl:
+ forall c sp pc rs m,
+ exec_instrs c sp pc rs m E0 pc rs m
+ | exec_one:
+ forall c sp pc rs m t pc' rs' m',
+ exec_instr c sp pc rs m t pc' rs' m' ->
+ exec_instrs c sp pc rs m t pc' rs' m'
+ | exec_trans:
+ forall c sp pc1 rs1 m1 t1 pc2 rs2 m2 t2 pc3 rs3 m3 t3,
+ exec_instrs c sp pc1 rs1 m1 t1 pc2 rs2 m2 ->
+ exec_instrs c sp pc2 rs2 m2 t2 pc3 rs3 m3 ->
+ t3 = t1 ** t2 ->
+ exec_instrs c sp pc1 rs1 m1 t3 pc3 rs3 m3.
+
+(** Some derived execution rules. *)
+
+Lemma exec_instrs_exec_body:
+ forall c sp pc1 rs1 m1 t1 pc2 rs2 m2,
+ exec_instrs c sp pc1 rs1 m1 t1 pc2 rs2 m2 ->
+ forall res t2 m3 t3,
+ exec_body c sp pc2 rs2 m2 t2 res m3 ->
+ t3 = t1 ** t2 ->
+ exec_body c sp pc1 rs1 m1 t3 res m3.
+Proof.
+ induction 1; intros.
+ subst t3. rewrite E0_left. auto.
+ eapply exec_body_step; eauto.
+ eapply IHexec_instrs1. eapply IHexec_instrs2. eauto.
+ eauto. traceEq.
+Qed.
+
+Lemma exec_step:
+ forall c sp pc1 rs1 m1 t1 pc2 rs2 m2 t2 pc3 rs3 m3 t3,
+ exec_instr c sp pc1 rs1 m1 t1 pc2 rs2 m2 ->
+ exec_instrs c sp pc2 rs2 m2 t2 pc3 rs3 m3 ->
+ t3 = t1 ** t2 ->
+ exec_instrs c sp pc1 rs1 m1 t3 pc3 rs3 m3.
+Proof.
+ intros. eapply exec_trans. apply exec_one. eauto. eauto. auto.
+Qed.
+
+Lemma exec_Iop':
+ forall c sp pc rs m op args res pc' rs' v,
+ c!pc = Some(Iop op args res pc') ->
+ eval_operation ge sp op rs##args m = Some v ->
+ rs' = (rs#res <- v) ->
+ exec_instr c sp pc rs m E0 pc' rs' m.
+Proof.
+ intros. subst rs'. eapply exec_Iop; eauto.
+Qed.
+
+Lemma exec_Iload':
+ forall c sp pc rs m chunk addr args dst pc' rs' a v,
+ c!pc = Some(Iload chunk addr args dst pc') ->
+ eval_addressing ge sp addr rs##args = Some a ->
+ Mem.loadv chunk m a = Some v ->
+ rs' = (rs#dst <- v) ->
+ exec_instr c sp pc rs m E0 pc' rs' m.
+Proof.
+ intros. subst rs'. eapply exec_Iload; eauto.
+Qed.
+
+(** Experimental: coinductive big-step semantics for divergence. *)
+
+CoInductive diverge_body:
+ code -> val -> node -> regset -> mem -> traceinf -> Prop :=
+ | diverge_step: forall c sp pc rs m t1 pc1 rs1 m1 T2 T,
+ exec_instr c sp pc rs m t1 pc1 rs1 m1 ->
+ diverge_body c sp pc1 rs1 m1 T2 ->
+ T = t1 *** T2 ->
+ diverge_body c sp pc rs m T
+ | diverge_Icall:
+ forall c sp pc rs m sig ros args res pc' f T,
+ c!pc = Some(Icall sig ros args res pc') ->
+ find_function ge ros rs = Some f ->
+ funsig f = sig ->
+ diverge_function f rs##args m T ->
+ diverge_body c sp pc rs m T
+ | diverge_Itailcall: forall c stk pc rs m sig ros args f T,
+ c!pc = Some(Itailcall sig ros args) ->
+ find_function ge ros rs = Some f ->
+ funsig f = sig ->
+ diverge_function f rs##args (Mem.free m stk) T ->
+ diverge_body c (Vptr stk Int.zero) pc rs m T
+
+with diverge_function: fundef -> list val -> mem -> traceinf -> Prop :=
+ | diverge_funct_internal:
+ forall f m m1 stk args T,
+ Mem.alloc m 0 f.(fn_stacksize) = (m1, stk) ->
+ diverge_body f.(fn_code) (Vptr stk Int.zero)
+ f.(fn_entrypoint) (init_regs args f.(fn_params)) m1
+ T ->
+ diverge_function (Internal f) args m T.
+
+End BIGSTEP.
+
+(** Execution of whole programs. *)
+
+Inductive exec_program (p: program): program_behavior -> Prop :=
+ | exec_program_terminates: forall b f t r m,
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ Genv.find_symbol ge p.(prog_main) = Some b ->
+ Genv.find_funct_ptr ge b = Some f ->
+ funsig f = mksignature nil (Some Tint) ->
+ exec_function ge f nil m0 t (Vint r) m ->
+ exec_program p (Terminates t r)
+ | exec_program_diverges: forall b f T,
+ let ge := Genv.globalenv p in
+ let m0 := Genv.init_mem p in
+ Genv.find_symbol ge p.(prog_main) = Some b ->
+ Genv.find_funct_ptr ge b = Some f ->
+ funsig f = mksignature nil (Some Tint) ->
+ diverge_function ge f nil m0 T ->
+ exec_program p (Diverges T).
+
+(** * Equivalence with the transition semantics. *)
+
+Section EQUIVALENCE.
+
+Variable ge: genv.
+
+Definition exec_instr_prop
+ (c: code) (sp: val) (pc1: node) (rs1: regset) (m1: mem)
+ (t: trace) (pc2: node) (rs2: regset) (m2: mem) : Prop :=
+ forall s,
+ plus step ge (State s c sp pc1 rs1 m1)
+ t (State s c sp pc2 rs2 m2).
+
+Definition exec_body_prop
+ (c: code) (sp: val) (pc1: node) (rs1: regset) (m1: mem)
+ (t: trace) (res: val) (m2: mem) : Prop :=
+ forall s,
+ plus step ge (State s c sp pc1 rs1 m1)
+ t (Returnstate s res m2).
+
+Definition exec_function_prop
+ (f: fundef) (args: list val) (m1: mem)
+ (t: trace) (res: val) (m2: mem) : Prop :=
+ forall s,
+ plus step ge (Callstate s f args m1)
+ t (Returnstate s res m2).
+
+Lemma exec_steps:
+ (forall c sp pc1 rs1 m1 t pc2 rs2 m2,
+ exec_instr ge c sp pc1 rs1 m1 t pc2 rs2 m2 ->
+ exec_instr_prop c sp pc1 rs1 m1 t pc2 rs2 m2) /\
+ (forall c sp pc1 rs1 m1 t res m2,
+ exec_body ge c sp pc1 rs1 m1 t res m2 ->
+ exec_body_prop c sp pc1 rs1 m1 t res m2) /\
+ (forall f args m1 t res m2,
+ exec_function ge f args m1 t res m2 ->
+ exec_function_prop f args m1 t res m2).
+Proof.
+ set (IND := fun a b c d e f g h i j k l m =>
+ conj (exec_instr_ind_3 ge exec_instr_prop exec_body_prop exec_function_prop a b c d e f g h i j k l m)
+ (conj (exec_body_ind_3 ge exec_instr_prop exec_body_prop exec_function_prop a b c d e f g h i j k l m)
+ (exec_function_ind_3 ge exec_instr_prop exec_body_prop exec_function_prop a b c d e f g h i j k l m))).
+ apply IND; clear IND;
+ intros; red; intros.
+ (* nop *)
+ apply plus_one. eapply RTL.exec_Inop; eauto.
+ (* op *)
+ apply plus_one. eapply RTL.exec_Iop'; eauto.
+ (* load *)
+ apply plus_one. eapply RTL.exec_Iload'; eauto.
+ (* store *)
+ apply plus_one. eapply RTL.exec_Istore; eauto.
+ (* call *)
+ eapply plus_left'. eapply RTL.exec_Icall; eauto.
+ eapply plus_right'. apply H3. apply RTL.exec_return.
+ eauto. traceEq.
+ (* alloc *)
+ apply plus_one. eapply RTL.exec_Ialloc; eauto.
+ (* cond true *)
+ apply plus_one. eapply RTL.exec_Icond_true; eauto.
+ (* cond false *)
+ apply plus_one. eapply RTL.exec_Icond_false; eauto.
+ (* body step *)
+ eapply plus_trans. apply H0. apply H2. auto.
+ (* body return *)
+ apply plus_one. rewrite H0. eapply RTL.exec_Ireturn; eauto.
+ (* body tailcall *)
+ eapply plus_left'. eapply RTL.exec_Itailcall; eauto.
+ apply H3. traceEq.
+ (* internal function *)
+ eapply plus_left'. eapply RTL.exec_function_internal; eauto.
+ apply H1. traceEq.
+ (* external function *)
+ apply plus_one. eapply RTL.exec_function_external; eauto.
+Qed.
+
+Lemma diverge_function_steps:
+ forall fd args m T s,
+ diverge_function ge fd args m T ->
+ forever step ge (Callstate s fd args m) T.
+Proof.
+ assert (diverge_function_steps':
+ forall fd args m T s,
+ diverge_function ge fd args m T ->
+ forever_N step ge O (Callstate s fd args m) T).
+ cofix COINDHYP1.
+ assert (diverge_body_steps: forall c sp pc rs m T s,
+ diverge_body ge c sp pc rs m T ->
+ forever_N step ge O (State s c sp pc rs m) T).
+ cofix COINDHYP2; intros.
+ inv H.
+ (* step *)
+ apply forever_N_plus with (State s c sp pc1 rs1 m1) O.
+ destruct exec_steps as [E [F G]].
+ apply E. assumption.
+ apply COINDHYP2. assumption.
+ (* call *)
+ change T with (E0 *** T).
+ apply forever_N_plus with (Callstate (Stackframe res c sp pc' rs :: s)
+ f rs##args m) O.
+ apply plus_one. eapply RTL.exec_Icall; eauto.
+ apply COINDHYP1. assumption.
+ (* tailcall *)
+ change T with (E0 *** T).
+ apply forever_N_plus with (Callstate s f rs##args (free m stk)) O.
+ apply plus_one. eapply RTL.exec_Itailcall; eauto.
+ apply COINDHYP1. assumption.
+ (* internal function *)
+ intros. inv H.
+ change T with (E0 *** T).
+ apply forever_N_plus with
+ (State s f.(fn_code) (Vptr stk Int.zero)
+ f.(fn_entrypoint) (init_regs args f.(fn_params)) m1) O.
+ apply plus_one. eapply RTL.exec_function_internal; eauto.
+ apply diverge_body_steps. assumption.
+ (* conclusion *)
+ intros. eapply forever_N_forever. eauto.
+Qed.
+
+End EQUIVALENCE.
+
+Theorem exec_program_bigstep_smallstep:
+ forall p beh,
+ exec_program p beh ->
+ RTL.exec_program p beh.
+Proof.
+ intros. unfold RTL.exec_program. inv H.
+ econstructor.
+ econstructor; eauto.
+ apply plus_star.
+ destruct (exec_steps (Genv.globalenv p)) as [E [F G]].
+ apply (G _ _ _ _ _ _ H3).
+ constructor.
+ econstructor.
+ econstructor; eauto.
+ apply diverge_function_steps. auto.
+Qed.
+
diff --git a/backend/RTLgen.v b/backend/RTLgen.v
index b38964d293248a77619194371bbe21cba06d54bb..117631eff75f10d2598ce4561183e58f49f12a7d 100644
--- a/backend/RTLgen.v
+++ b/backend/RTLgen.v
@@ -1,21 +1,25 @@
-(** Translation from Cminor to RTL. *)
+(** Translation from CminorSel to RTL. *)
Require Import Coqlib.
+Require Errors.
Require Import Maps.
Require Import AST.
Require Import Integers.
Require Import Values.
+Require Import Switch.
Require Import Op.
Require Import Registers.
-Require Import Cminor.
+Require Import CminorSel.
Require Import RTL.
+Open Local Scope string_scope.
+
(** * Translation environments and state *)
(** The translation functions are parameterized by the following
- compile-time environment, which maps Cminor local variables and
+ compile-time environment, which maps CminorSel local variables and
let-bound variables to RTL registers. The mapping for local variables
- is computed from the Cminor variable declarations at the beginning of
+ is computed from the CminorSel variable declarations at the beginning of
the translation of a function, and does not change afterwards.
The mapping for let-bound variables is initially empty and updated
during translation of expressions, when crossing a [Elet] binding. *)
@@ -46,9 +50,10 @@ Record state: Set := mkstate {
to modify the global state. These luxuries are not available in Coq,
however. Instead, we use a monadic encoding of the translation:
translation functions take the current global state as argument,
- and return either [Error] to denote an error, or [OK r s] to denote
+ and return either [Error msg] to denote an error, or [OK r s] to denote
success. [s] is the modified state, and [r] the result value of the
- translation function.
+ translation function. In the error case, [msg] is an error message
+ (see modules [Errors]) describing the problem.
We now define this monadic encoding -- the ``state and error'' monad --
as well as convenient syntax to express monadic computations. *)
@@ -56,19 +61,19 @@ Record state: Set := mkstate {
Set Implicit Arguments.
Inductive res (A: Set) : Set :=
- | Error: res A
+ | Error: Errors.errmsg -> res A
| OK: A -> state -> res A.
Definition mon (A: Set) : Set := state -> res A.
Definition ret (A: Set) (x: A) : mon A := fun (s: state) => OK x s.
-Definition error (A: Set) : mon A := fun (s: state) => Error A.
+Definition error (A: Set) (msg: Errors.errmsg) : mon A := fun (s: state) => Error A msg.
Definition bind (A B: Set) (f: mon A) (g: A -> mon B) : mon B :=
fun (s: state) =>
match f s with
- | Error => Error B
+ | Error msg => Error B msg
| OK a s' => g a s'
end.
@@ -155,7 +160,7 @@ Definition update_instr (n: node) (i: instruction) : mon unit :=
(PTree.set n i s.(st_code))
(@update_instr_wf s n i PEQ))
| right _ =>
- Error unit
+ Error unit (Errors.msg "RTLgen.update_instr")
end.
(** Generate a fresh RTL register. *)
@@ -188,7 +193,7 @@ Fixpoint add_vars (map: mapping) (names: list ident)
Definition find_var (map: mapping) (name: ident) : mon reg :=
match PTree.get name map.(map_vars) with
- | None => error reg
+ | None => error reg (Errors.MSG "RTLgen: unbound variable " :: Errors.CTX name :: nil)
| Some r => ret r
end.
@@ -197,7 +202,7 @@ Definition add_letvar (map: mapping) (r: reg) : mapping :=
Definition find_letvar (map: mapping) (idx: nat) : mon reg :=
match List.nth_error map.(map_letvars) idx with
- | None => error reg
+ | None => error reg (Errors.msg "RTLgen: unbound let variable")
| Some r => ret r
end.
@@ -227,8 +232,8 @@ Fixpoint alloc_regs (map: mapping) (al: exprlist)
| Enil =>
ret nil
| Econs a bl =>
- do rl <- alloc_regs map bl;
do r <- alloc_reg map a;
+ do rl <- alloc_regs map bl;
ret (r :: rl)
end.
@@ -241,9 +246,9 @@ Definition add_move (rs rd: reg) (nd: node) : mon node :=
then ret nd
else add_instr (Iop Omove (rs::nil) rd nd).
-(** Translation of an expression. [transl_expr map mut a rd nd]
+(** Translation of an expression. [transl_expr map a rd nd]
enriches the current CFG with the RTL instructions necessary
- to compute the value of Cminor expression [a], leave its result
+ to compute the value of CminorSel expression [a], leave its result
in register [rd], and branch to node [nd]. It returns the node
of the first instruction in this sequence. [map] is the compile-time
translation environment. *)
@@ -311,7 +316,7 @@ with transl_condition (map: mapping) (a: condexpr) (ntrue nfalse: node)
end
(** Translation of a list of expressions. The expressions are evaluated
- left-to-right, and their values left in the given list of registers. *)
+ left-to-right, and their values stored in the given list of registers. *)
with transl_exprlist (map: mapping) (al: exprlist) (rl: list reg) (nd: node)
{struct al} : mon node :=
@@ -321,7 +326,7 @@ with transl_exprlist (map: mapping) (al: exprlist) (rl: list reg) (nd: node)
| Econs b bs, r :: rs =>
do no <- transl_exprlist map bs rs nd; transl_expr map b r no
| _, _ =>
- error node
+ error node (Errors.msg "RTLgen.transl_exprlist")
end.
(** Auxiliary for branch prediction. When compiling an if/then/else
@@ -336,27 +341,32 @@ Parameter more_likely: condexpr -> stmt -> stmt -> bool.
(** Auxiliary for translating [Sswitch] statements. *)
+Parameter compile_switch: nat -> table -> comptree.
+
Definition transl_exit (nexits: list node) (n: nat) : mon node :=
match nth_error nexits n with
- | None => error node
+ | None => error node (Errors.msg "RTLgen: wrong exit")
| Some ne => ret ne
end.
-Fixpoint transl_switch (r: reg) (nexits: list node)
- (cases: list (int * nat)) (default: nat)
- {struct cases} : mon node :=
- match cases with
- | nil =>
- transl_exit nexits default
- | (key1, exit1) :: cases' =>
- do ncont <- transl_switch r nexits cases' default;
- do nfound <- transl_exit nexits exit1;
- add_instr (Icond (Ccompimm Ceq key1) (r :: nil) nfound ncont)
+Fixpoint transl_switch (r: reg) (nexits: list node) (t: comptree)
+ {struct t} : mon node :=
+ match t with
+ | CTaction act =>
+ transl_exit nexits act
+ | CTifeq key act t' =>
+ do ncont <- transl_switch r nexits t';
+ do nfound <- transl_exit nexits act;
+ add_instr (Icond (Ccompimm Ceq key) (r :: nil) nfound ncont)
+ | CTiflt key t1 t2 =>
+ do n2 <- transl_switch r nexits t2;
+ do n1 <- transl_switch r nexits t1;
+ add_instr (Icond (Ccompuimm Clt key) (r :: nil) n1 n2)
end.
(** Translation of statements. [transl_stmt map s nd nexits nret rret]
enriches the current CFG with the RTL instructions necessary to
- execute the Cminor statement [s], and returns the node of the first
+ execute the CminorSel statement [s], and returns the node of the first
instruction in this sequence. The generated instructions continue
at node [nd] if the statement terminates normally, at node [nret]
if it terminates by early return, and at the [n]-th node in the list
@@ -398,18 +408,28 @@ Fixpoint transl_stmt (map: mapping) (s: stmt) (nd: node)
| Sexit n =>
transl_exit nexits n
| Sswitch a cases default =>
- do r <- alloc_reg map a;
- do ns <- transl_switch r nexits cases default;
- transl_expr map a r ns
+ let t := compile_switch default cases in
+ if validate_switch default cases t then
+ (do r <- alloc_reg map a;
+ do ns <- transl_switch r nexits t;
+ transl_expr map a r ns)
+ else
+ error node (Errors.msg "RTLgen: wrong switch")
| Sreturn opt_a =>
match opt_a, rret with
| None, None => ret nret
| Some a, Some r => transl_expr map a r nret
- | _, _ => error node
+ | _, _ => error node (Errors.msg "RTLgen: type mismatch on return")
end
+ | Stailcall sig b cl =>
+ do rf <- alloc_reg map b;
+ do rargs <- alloc_regs map cl;
+ do n1 <- add_instr (Itailcall sig (inl _ rf) rargs);
+ do n2 <- transl_exprlist map cl rargs n1;
+ transl_expr map b rf n2
end.
-(** Translation of a Cminor function. *)
+(** Translation of a CminorSel function. *)
Definition ret_reg (sig: signature) (rd: reg) : option reg :=
match sig.(sig_res) with
@@ -417,32 +437,32 @@ Definition ret_reg (sig: signature) (rd: reg) : option reg :=
| Some ty => Some rd
end.
-Definition transl_fun (f: Cminor.function) : mon (node * list reg) :=
- do (rparams, map1) <- add_vars init_mapping f.(Cminor.fn_params);
- do (rvars, map2) <- add_vars map1 f.(Cminor.fn_vars);
+Definition transl_fun (f: CminorSel.function) : mon (node * list reg) :=
+ do (rparams, map1) <- add_vars init_mapping f.(CminorSel.fn_params);
+ do (rvars, map2) <- add_vars map1 f.(CminorSel.fn_vars);
do rret <- new_reg;
- let orret := ret_reg f.(Cminor.fn_sig) rret in
+ let orret := ret_reg f.(CminorSel.fn_sig) rret in
do nret <- add_instr (Ireturn orret);
- do nentry <- transl_stmt map2 f.(Cminor.fn_body) nret nil nret orret;
+ do nentry <- transl_stmt map2 f.(CminorSel.fn_body) nret nil nret orret;
ret (nentry, rparams).
-Definition transl_function (f: Cminor.function) : option RTL.function :=
+Definition transl_function (f: CminorSel.function) : Errors.res RTL.function :=
match transl_fun f init_state with
- | Error => None
+ | Error msg => Errors.Error msg
| OK (nentry, rparams) s =>
- Some (RTL.mkfunction
- f.(Cminor.fn_sig)
- rparams
- f.(Cminor.fn_stackspace)
- s.(st_code)
- nentry
- s.(st_nextnode)
- s.(st_wf))
+ Errors.OK (RTL.mkfunction
+ f.(CminorSel.fn_sig)
+ rparams
+ f.(CminorSel.fn_stackspace)
+ s.(st_code)
+ nentry
+ s.(st_nextnode)
+ s.(st_wf))
end.
Definition transl_fundef := transf_partial_fundef transl_function.
(** Translation of a whole program. *)
-Definition transl_program (p: Cminor.program) : option RTL.program :=
+Definition transl_program (p: CminorSel.program) : Errors.res RTL.program :=
transform_partial_program transl_fundef p.
diff --git a/backend/RTLgenproof.v b/backend/RTLgenproof.v
index 2ce961bcd9489317307ef97ecb5ac3203b16235a..15f305a8b6c6b8c102b618f93f39bb1c9fab1328 100644
--- a/backend/RTLgenproof.v
+++ b/backend/RTLgenproof.v
@@ -1,4 +1,4 @@
-(** Correctness proof for RTL generation: main proof. *)
+(** Correctness proof for RTL generation. *)
Require Import Coqlib.
Require Import Maps.
@@ -7,144 +7,411 @@ Require Import Integers.
Require Import Values.
Require Import Mem.
Require Import Events.
+Require Import Smallstep.
Require Import Globalenvs.
-Require Import Op.
+Require Import Switch.
Require Import Registers.
Require Import Cminor.
+Require Import Op.
+Require Import CminorSel.
Require Import RTL.
Require Import RTLgen.
-Require Import RTLgenproof1.
+Require Import RTLgenspec.
+
+(** * Correspondence between Cminor environments and RTL register sets *)
+
+(** A compilation environment (mapping) is well-formed if
+ the following properties hold:
+- Two distinct Cminor local variables are mapped to distinct pseudo-registers.
+- A Cminor local variable and a let-bound variable are mapped to
+ distinct pseudo-registers.
+*)
+
+Record map_wf (m: mapping) : Prop :=
+ mk_map_wf {
+ map_wf_inj:
+ (forall id1 id2 r,
+ m.(map_vars)!id1 = Some r -> m.(map_vars)!id2 = Some r -> id1 = id2);
+ map_wf_disj:
+ (forall id r,
+ m.(map_vars)!id = Some r -> In r m.(map_letvars) -> False)
+ }.
+
+Lemma init_mapping_wf:
+ map_wf init_mapping.
+Proof.
+ unfold init_mapping; split; simpl.
+ intros until r. rewrite PTree.gempty. congruence.
+ tauto.
+Qed.
+
+Lemma add_var_wf:
+ forall s1 s2 map name r map',
+ add_var map name s1 = OK (r,map') s2 ->
+ map_wf map -> map_valid map s1 -> map_wf map'.
+Proof.
+ intros. monadInv H.
+ apply mk_map_wf; simpl.
+ intros until r0. repeat rewrite PTree.gsspec.
+ destruct (peq id1 name); destruct (peq id2 name).
+ congruence.
+ intros. inv H. elimtype False.
+ apply valid_fresh_absurd with r0 s1.
+ apply H1. left; exists id2; auto.
+ eauto with rtlg.
+ intros. inv H2. elimtype False.
+ apply valid_fresh_absurd with r0 s1.
+ apply H1. left; exists id1; auto.
+ eauto with rtlg.
+ inv H0. eauto.
+ intros until r0. rewrite PTree.gsspec.
+ destruct (peq id name).
+ intros. inv H.
+ apply valid_fresh_absurd with r0 s1.
+ apply H1. right; auto.
+ eauto with rtlg.
+ inv H0; eauto.
+Qed.
+
+Lemma add_vars_wf:
+ forall names s1 s2 map map' rl,
+ add_vars map names s1 = OK (rl,map') s2 ->
+ map_wf map -> map_valid map s1 -> map_wf map'.
+Proof.
+ induction names; simpl; intros; monadInv H.
+ auto.
+ exploit add_vars_valid; eauto. intros [A B].
+ eapply add_var_wf; eauto.
+Qed.
+
+Lemma add_letvar_wf:
+ forall map r,
+ map_wf map -> ~reg_in_map map r -> map_wf (add_letvar map r).
+Proof.
+ intros. inv H. unfold add_letvar; constructor; simpl.
+ auto.
+ intros. elim H1; intro. subst r0. elim H0. left; exists id; auto.
+ eauto.
+Qed.
+
+(** An RTL register environment matches a Cminor local environment and
+ let-environment if the value of every local or let-bound variable in
+ the Cminor environments is identical to the value of the
+ corresponding pseudo-register in the RTL register environment. *)
+
+Record match_env
+ (map: mapping) (e: Cminor.env) (le: Cminor.letenv) (rs: regset) : Prop :=
+ mk_match_env {
+ me_vars:
+ (forall id v,
+ e!id = Some v -> exists r, map.(map_vars)!id = Some r /\ rs#r = v);
+ me_letvars:
+ rs##(map.(map_letvars)) = le
+ }.
+
+Lemma match_env_find_var:
+ forall map e le rs id v r,
+ match_env map e le rs ->
+ e!id = Some v ->
+ map.(map_vars)!id = Some r ->
+ rs#r = v.
+Proof.
+ intros. exploit me_vars; eauto. intros [r' [EQ' RS]].
+ replace r with r'. auto. congruence.
+Qed.
+
+Lemma match_env_find_letvar:
+ forall map e le rs idx v r,
+ match_env map e le rs ->
+ List.nth_error le idx = Some v ->
+ List.nth_error map.(map_letvars) idx = Some r ->
+ rs#r = v.
+Proof.
+ intros. exploit me_letvars; eauto. intros.
+ rewrite <- H2 in H0. rewrite list_map_nth in H0.
+ change reg with positive in H1. rewrite H1 in H0.
+ simpl in H0. congruence.
+Qed.
+
+Lemma match_env_invariant:
+ forall map e le rs rs',
+ match_env map e le rs ->
+ (forall r, (reg_in_map map r) -> rs'#r = rs#r) ->
+ match_env map e le rs'.
+Proof.
+ intros. inversion H. apply mk_match_env.
+ intros. exploit me_vars0; eauto. intros [r [A B]].
+ exists r; split. auto. rewrite H0; auto. left; exists id; auto.
+ rewrite <- me_letvars0. apply list_map_exten. intros.
+ symmetry. apply H0. right; auto.
+Qed.
+
+(** Matching between environments is preserved when an unmapped register
+ (not corresponding to any Cminor variable) is assigned in the RTL
+ execution. *)
+
+Lemma match_env_update_temp:
+ forall map e le rs r v,
+ match_env map e le rs ->
+ ~(reg_in_map map r) ->
+ match_env map e le (rs#r <- v).
+Proof.
+ intros. apply match_env_invariant with rs; auto.
+ intros. case (Reg.eq r r0); intro.
+ subst r0; contradiction.
+ apply Regmap.gso; auto.
+Qed.
+Hint Resolve match_env_update_temp: rtlg.
+
+(** Matching between environments is preserved by simultaneous
+ assignment to a Cminor local variable (in the Cminor environments)
+ and to the corresponding RTL pseudo-register (in the RTL register
+ environment). *)
+
+Lemma match_env_update_var:
+ forall map e le rs id r v,
+ map_wf map ->
+ map.(map_vars)!id = Some r ->
+ match_env map e le rs ->
+ match_env map (PTree.set id v e) le (rs#r <- v).
+Proof.
+ intros. inversion H. inversion H1. apply mk_match_env.
+ intros id' v'. rewrite PTree.gsspec. destruct (peq id' id); intros.
+ subst id'. inv H2. exists r; split. auto. apply PMap.gss.
+ exploit me_vars0; eauto. intros [r' [A B]].
+ exists r'; split. auto. rewrite PMap.gso; auto.
+ red; intros. subst r'. elim n. eauto.
+ rewrite <- me_letvars0. apply list_map_exten; intros.
+ symmetry. apply PMap.gso. red; intros. subst x. eauto.
+Qed.
+
+Lemma match_env_bind_letvar:
+ forall map e le rs r v,
+ match_env map e le rs ->
+ rs#r = v ->
+ match_env (add_letvar map r) e (v :: le) rs.
+Proof.
+ intros. inv H. unfold add_letvar. apply mk_match_env; simpl; auto.
+Qed.
+
+Lemma match_env_unbind_letvar:
+ forall map e le rs r v,
+ match_env (add_letvar map r) e (v :: le) rs ->
+ match_env map e le rs.
+Proof.
+ unfold add_letvar; intros. inv H. simpl in *.
+ constructor. auto. congruence.
+Qed.
+
+Lemma match_env_empty:
+ forall map,
+ map.(map_letvars) = nil ->
+ match_env map (PTree.empty val) nil (Regmap.init Vundef).
+Proof.
+ intros. apply mk_match_env.
+ intros. rewrite PTree.gempty in H0. discriminate.
+ rewrite H. reflexivity.
+Qed.
+
+(** The assignment of function arguments to local variables (on the Cminor
+ side) and pseudo-registers (on the RTL side) preserves matching
+ between environments. *)
+
+Lemma match_set_params_init_regs:
+ forall il rl s1 map2 s2 vl,
+ add_vars init_mapping il s1 = OK (rl, map2) s2 ->
+ match_env map2 (set_params vl il) nil (init_regs vl rl)
+ /\ (forall r, reg_fresh r s2 -> (init_regs vl rl)#r = Vundef).
+Proof.
+ induction il; intros.
+
+ inv H. split. apply match_env_empty. auto. intros.
+ simpl. apply Regmap.gi.
+
+ monadInv H. simpl.
+ exploit add_vars_valid; eauto. apply init_mapping_valid. intros [A B].
+ exploit add_var_valid; eauto. intros [A' B']. clear B'.
+ monadInv EQ1.
+ destruct vl as [ | v1 vs].
+ (* vl = nil *)
+ destruct (IHil _ _ _ _ nil EQ) as [ME UNDEF]. inv ME. split.
+ constructor; simpl.
+ intros id v. repeat rewrite PTree.gsspec. destruct (peq id a); intros.
+ subst a. inv H. exists x1; split. auto. apply Regmap.gi.
+ replace (init_regs nil x) with (Regmap.init Vundef) in me_vars0. eauto.
+ destruct x; reflexivity.
+ destruct (map_letvars x0). auto. simpl in me_letvars0. congruence.
+ intros. apply Regmap.gi.
+ (* vl = v1 :: vs *)
+ destruct (IHil _ _ _ _ vs EQ) as [ME UNDEF]. inv ME. split.
+ constructor; simpl.
+ intros id v. repeat rewrite PTree.gsspec. destruct (peq id a); intros.
+ subst a. inv H. exists x1; split. auto. apply Regmap.gss.
+ exploit me_vars0; eauto. intros [r' [C D]].
+ exists r'; split. auto. rewrite Regmap.gso. auto.
+ apply valid_fresh_different with s.
+ apply B. left; exists id; auto.
+ eauto with rtlg.
+ destruct (map_letvars x0). auto. simpl in me_letvars0. congruence.
+ intros. rewrite Regmap.gso. apply UNDEF.
+ apply reg_fresh_decr with s2; eauto with rtlg.
+ apply sym_not_equal. apply valid_fresh_different with s2; auto.
+Qed.
+
+Lemma match_set_locals:
+ forall map1 s1,
+ map_wf map1 ->
+ forall il rl map2 s2 e le rs,
+ match_env map1 e le rs ->
+ (forall r, reg_fresh r s1 -> rs#r = Vundef) ->
+ add_vars map1 il s1 = OK (rl, map2) s2 ->
+ match_env map2 (set_locals il e) le rs.
+Proof.
+ induction il; simpl in *; intros.
+
+ inv H2. auto.
+
+ monadInv H2.
+ exploit IHil; eauto. intro.
+ monadInv EQ1.
+ constructor.
+ intros id v. simpl. repeat rewrite PTree.gsspec.
+ destruct (peq id a). subst a. intro.
+ exists x1. split. auto. inv H3.
+ apply H1. apply reg_fresh_decr with s.
+ eapply add_vars_incr; eauto.
+ eauto with rtlg.
+ intros. eapply me_vars; eauto.
+ simpl. eapply me_letvars; eauto.
+Qed.
+
+Lemma match_init_env_init_reg:
+ forall params s0 rparams map1 s1 vars rvars map2 s2 vparams,
+ add_vars init_mapping params s0 = OK (rparams, map1) s1 ->
+ add_vars map1 vars s1 = OK (rvars, map2) s2 ->
+ match_env map2 (set_locals vars (set_params vparams params))
+ nil (init_regs vparams rparams).
+Proof.
+ intros.
+ exploit match_set_params_init_regs; eauto. intros [A B].
+ eapply match_set_locals; eauto.
+ eapply add_vars_wf; eauto. apply init_mapping_wf.
+ apply init_mapping_valid.
+Qed.
+
+(** * The simulation argument *)
+
+Require Import Errors.
Section CORRECTNESS.
-Variable prog: Cminor.program.
+Variable prog: CminorSel.program.
Variable tprog: RTL.program.
-Hypothesis TRANSL: transl_program prog = Some tprog.
+Hypothesis TRANSL: transl_program prog = OK tprog.
-Let ge : Cminor.genv := Genv.globalenv prog.
+Let ge : CminorSel.genv := Genv.globalenv prog.
Let tge : RTL.genv := Genv.globalenv tprog.
(** Relationship between the global environments for the original
- Cminor program and the generated RTL program. *)
+ CminorSel program and the generated RTL program. *)
Lemma symbols_preserved:
forall (s: ident), Genv.find_symbol tge s = Genv.find_symbol ge s.
-Proof.
- intro. unfold ge, tge.
- apply Genv.find_symbol_transf_partial with transl_fundef.
- exact TRANSL.
-Qed.
+Proof
+ (Genv.find_symbol_transf_partial transl_fundef _ TRANSL).
Lemma function_ptr_translated:
- forall (b: block) (f: Cminor.fundef),
+ forall (b: block) (f: CminorSel.fundef),
Genv.find_funct_ptr ge b = Some f ->
exists tf,
- Genv.find_funct_ptr tge b = Some tf /\ transl_fundef f = Some tf.
-Proof.
- intros.
- generalize
- (Genv.find_funct_ptr_transf_partial transl_fundef TRANSL H).
- case (transl_fundef f).
- intros tf [A B]. exists tf. tauto.
- intros [A B]. elim B. reflexivity.
-Qed.
+ Genv.find_funct_ptr tge b = Some tf /\ transl_fundef f = OK tf.
+Proof
+ (Genv.find_funct_ptr_transf_partial transl_fundef TRANSL).
Lemma functions_translated:
- forall (v: val) (f: Cminor.fundef),
+ forall (v: val) (f: CminorSel.fundef),
Genv.find_funct ge v = Some f ->
exists tf,
- Genv.find_funct tge v = Some tf /\ transl_fundef f = Some tf.
-Proof.
- intros.
- generalize
- (Genv.find_funct_transf_partial transl_fundef TRANSL H).
- case (transl_fundef f).
- intros tf [A B]. exists tf. tauto.
- intros [A B]. elim B. reflexivity.
-Qed.
+ Genv.find_funct tge v = Some tf /\ transl_fundef f = OK tf.
+Proof
+ (Genv.find_funct_transf_partial transl_fundef TRANSL).
Lemma sig_transl_function:
- forall (f: Cminor.fundef) (tf: RTL.fundef),
- transl_fundef f = Some tf ->
- RTL.funsig tf = Cminor.funsig f.
+ forall (f: CminorSel.fundef) (tf: RTL.fundef),
+ transl_fundef f = OK tf ->
+ RTL.funsig tf = CminorSel.funsig f.
Proof.
intros until tf. unfold transl_fundef, transf_partial_fundef.
case f; intro.
unfold transl_function.
- case (transl_fun f0 init_state); intros.
+ case (transl_fun f0 init_state); simpl; intros.
discriminate.
- destruct p. inversion H. reflexivity.
+ destruct p. simpl in H. inversion H. reflexivity.
intro. inversion H. reflexivity.
Qed.
(** Correctness of the code generated by [add_move]. *)
-Lemma add_move_correct:
- forall r1 r2 sp nd s ns s' rs m,
- add_move r1 r2 nd s = OK ns s' ->
+Lemma tr_move_correct:
+ forall r1 ns r2 nd cs code sp rs m,
+ tr_move code ns r1 nd r2 ->
exists rs',
- exec_instrs tge s'.(st_code) sp ns rs m E0 nd rs' m /\
+ star step tge (State cs code sp ns rs m) E0 (State cs code sp nd rs' m) /\
rs'#r2 = rs#r1 /\
(forall r, r <> r2 -> rs'#r = rs#r).
Proof.
- intros until m.
- unfold add_move. case (Reg.eq r1 r2); intro.
- monadSimpl. subst s'; subst r2; subst ns.
- exists rs. split. apply exec_refl. split. auto. auto.
- intro. exists (rs#r2 <- (rs#r1)).
- split. apply exec_one. eapply exec_Iop. eauto with rtlg.
- reflexivity.
- split. apply Regmap.gss.
- intros. apply Regmap.gso; auto.
+ intros. inv H.
+ exists rs; split. constructor. auto.
+ exists (rs#r2 <- (rs#r1)); split.
+ apply star_one. eapply exec_Iop. eauto. auto.
+ split. apply Regmap.gss. intros; apply Regmap.gso; auto.
Qed.
(** The proof of semantic preservation for the translation of expressions
is a simulation argument based on diagrams of the following form:
<<
I /\ P
- e, m, a ------------- ns, rs, m
+ e, le, m, a ------------- State cs code sp ns rs m
|| |
- || |*
+ t|| t|*
|| |
\/ v
- e', m', v ----------- nd, rs', m'
+ e, le, m', v ------------ State cs code sp nd rs' m'
I /\ Q
>>
- where [transl_expr map mut a rd nd s = OK ns s'].
+ where [tr_expr code map pr a ns nd rd] is assumed to hold.
The left vertical arrow represents an evaluation of the expression [a]
- (assumption). The right vertical arrow represents the execution of
- zero, one or several instructions in the generated RTL flow graph
- found in the final state [s'] (conclusion).
+ to value [v].
+ The right vertical arrow represents the execution of zero, one or
+ several instructions in the generated RTL flow graph [code].
- The invariant [I] is the agreement between Cminor environments and
- RTL register environment, as captured by [match_envs].
+ The invariant [I] is the agreement between CminorSel environments
+ [e], [le] and the RTL register environment [rs],
+ as captured by [match_envs].
- The preconditions [P] include the well-formedness of the compilation
- environment [mut] and the validity of [rd] as a target register.
+ The precondition [P] is the well-formedness of the compilation
+ environment [mut].
The postconditions [Q] state that in the final register environment
- [rs'], register [rd] contains value [v], and most other registers
- valid in [s] are unchanged w.r.t. the initial register environment
- [rs]. (See below for a precise specification of ``most other
- registers''.)
+ [rs'], register [rd] contains value [v], and the registers in
+ the set of preserved registers [pr] are unchanged, as are the registers
+ in the codomain of [map].
We formalize this simulation property by the following predicate
- parameterized by the Cminor evaluation (left arrow). *)
+ parameterized by the CminorSel evaluation (left arrow). *)
Definition transl_expr_correct
(sp: val) (le: letenv) (e: env) (m: mem) (a: expr)
(t: trace) (m': mem) (v: val) : Prop :=
- forall map rd nd s ns s' rs
- (MWF: map_wf map s)
- (TE: transl_expr map a rd nd s = OK ns s')
- (ME: match_env map e le rs)
- (TRG: target_reg_ok s map a rd),
+ forall cs code map pr ns nd rd rs
+ (MWF: map_wf map)
+ (TE: tr_expr code map pr a ns nd rd)
+ (ME: match_env map e le rs),
exists rs',
- exec_instrs tge s'.(st_code) sp ns rs m t nd rs' m'
+ star step tge (State cs code sp ns rs m) t (State cs code sp nd rs' m')
/\ match_env map e le rs'
/\ rs'#rd = v
- /\ (forall r,
- reg_valid r s -> reg_in_map map r \/ r <> rd -> rs'#r = rs#r).
+ /\ (forall r, reg_in_map map r \/ In r pr -> rs'#r = rs#r).
(** The simulation properties for lists of expressions and for
conditional expressions are similar. *)
@@ -152,122 +419,113 @@ Definition transl_expr_correct
Definition transl_exprlist_correct
(sp: val) (le: letenv) (e: env) (m: mem) (al: exprlist)
(t: trace) (m': mem) (vl: list val) : Prop :=
- forall map rl nd s ns s' rs
- (MWF: map_wf map s)
- (TE: transl_exprlist map al rl nd s = OK ns s')
- (ME: match_env map e le rs)
- (TRG: target_regs_ok s map al rl),
+ forall cs code map pr ns nd rl rs
+ (MWF: map_wf map)
+ (TE: tr_exprlist code map pr al ns nd rl)
+ (ME: match_env map e le rs),
exists rs',
- exec_instrs tge s'.(st_code) sp ns rs m t nd rs' m'
+ star step tge (State cs code sp ns rs m) t (State cs code sp nd rs' m')
/\ match_env map e le rs'
/\ rs'##rl = vl
- /\ (forall r,
- reg_valid r s -> reg_in_map map r \/ ~(In r rl) -> rs'#r = rs#r).
+ /\ (forall r, reg_in_map map r \/ In r pr -> rs'#r = rs#r).
Definition transl_condition_correct
(sp: val) (le: letenv) (e: env) (m: mem) (a: condexpr)
(t: trace) (m': mem) (vb: bool) : Prop :=
- forall map ntrue nfalse s ns s' rs
- (MWF: map_wf map s)
- (TE: transl_condition map a ntrue nfalse s = OK ns s')
+ forall cs code map pr ns ntrue nfalse rs
+ (MWF: map_wf map)
+ (TE: tr_condition code map pr a ns ntrue nfalse)
(ME: match_env map e le rs),
exists rs',
- exec_instrs tge s'.(st_code) sp ns rs m t (if vb then ntrue else nfalse) rs' m'
+ star step tge (State cs code sp ns rs m) t
+ (State cs code sp (if vb then ntrue else nfalse) rs' m')
/\ match_env map e le rs'
- /\ (forall r, reg_valid r s -> rs'#r = rs#r).
-
-(** For statements, we define the following auxiliary predicates
- relating the outcome of the Cminor execution with the final node
- and value of the return register in the RTL execution. *)
-
-Definition outcome_node
- (out: outcome)
- (ncont: node) (nexits: list node) (nret: node) (nd: node) : Prop :=
- match out with
- | Out_normal => ncont = nd
- | Out_exit n => nth_error nexits n = Some nd
- | Out_return _ => nret = nd
- end.
-
-Definition match_return_reg
- (rs: regset) (rret: option reg) (v: val) : Prop :=
- match rret with
- | None => True
- | Some r => rs#r = v
- end.
-
-Definition match_return_outcome
- (out: outcome) (rret: option reg) (rs: regset) : Prop :=
- match out with
- | Out_normal => True
- | Out_exit n => True
- | Out_return optv =>
- match rret, optv with
- | None, None => True
- | Some r, Some v => rs#r = v
- | _, _ => False
- end
- end.
+ /\ (forall r, reg_in_map map r \/ In r pr -> rs'#r = rs#r).
+
(** The simulation diagram for the translation of statements
is of the following form:
<<
I /\ P
- e, m, a ------------- ns, rs, m
+ e, m, a -------------- State cs code sp ns rs m
|| |
- || |*
+ t|| t|*
|| |
\/ v
- e', m', out --------- nd, rs', m'
+ e', m', out -------------- st'
I /\ Q
>>
- where [transl_stmt map a ncont nexits nret rret s = OK ns s'].
+ where [tr_stmt code map a ns ncont nexits nret rret] holds.
The left vertical arrow represents an execution of the statement [a]
- (assumption). The right vertical arrow represents the execution of
- zero, one or several instructions in the generated RTL flow graph
- found in the final state [s'] (conclusion).
+ with outcome [out].
+ The right vertical arrow represents the execution of
+ zero, one or several instructions in the generated RTL flow graph [code].
- The invariant [I] is the agreement between Cminor environments and
+ The invariant [I] is the agreement between CminorSel environments and
RTL register environment, as captured by [match_envs].
- The preconditions [P] include the well-formedness of the compilation
- environment [mut] and the agreement between the outcome [out]
- and the end node [nd].
-
- The postcondition [Q] states agreement between the outcome [out]
- and the value of the return register [rret]. *)
+ The precondition [P] is the well-formedness of the compilation
+ environment [mut].
+
+ The postcondition [Q] characterizes the final RTL state [st'].
+ It must have memory state [m'] and a register state [rs'] that matches
+ [e']. Moreover, the program point reached must correspond to the outcome
+ [out]. This is captured by the following [state_for_outcome] predicate. *)
+
+Inductive state_for_outcome
+ (ncont: node) (nexits: list node) (nret: node) (rret: option reg)
+ (cs: list stackframe) (c: code) (sp: val) (rs: regset) (m: mem):
+ outcome -> RTL.state -> Prop :=
+ | state_for_normal:
+ state_for_outcome ncont nexits nret rret cs c sp rs m
+ Out_normal (State cs c sp ncont rs m)
+ | state_for_exit: forall n nexit,
+ nth_error nexits n = Some nexit ->
+ state_for_outcome ncont nexits nret rret cs c sp rs m
+ (Out_exit n) (State cs c sp nexit rs m)
+ | state_for_return_none:
+ rret = None ->
+ state_for_outcome ncont nexits nret rret cs c sp rs m
+ (Out_return None) (State cs c sp nret rs m)
+ | state_for_return_some: forall r v,
+ rret = Some r ->
+ rs#r = v ->
+ state_for_outcome ncont nexits nret rret cs c sp rs m
+ (Out_return (Some v)) (State cs c sp nret rs m)
+ | state_for_return_tail: forall v,
+ state_for_outcome ncont nexits nret rret cs c sp rs m
+ (Out_tailcall_return v) (Returnstate cs v m).
Definition transl_stmt_correct
(sp: val) (e: env) (m: mem) (a: stmt)
(t: trace) (e': env) (m': mem) (out: outcome) : Prop :=
- forall map ncont nexits nret rret s ns s' nd rs
- (MWF: map_wf map s)
- (TE: transl_stmt map a ncont nexits nret rret s = OK ns s')
- (ME: match_env map e nil rs)
- (OUT: outcome_node out ncont nexits nret nd)
- (RRG: return_reg_ok s map rret),
- exists rs',
- exec_instrs tge s'.(st_code) sp ns rs m t nd rs' m'
- /\ match_env map e' nil rs'
- /\ match_return_outcome out rret rs'.
+ forall cs code map ns ncont nexits nret rret rs
+ (MWF: map_wf map)
+ (TE: tr_stmt code map a ns ncont nexits nret rret)
+ (ME: match_env map e nil rs),
+ exists rs', exists st,
+ state_for_outcome ncont nexits nret rret cs code sp rs' m' out st
+ /\ star step tge (State cs code sp ns rs m) t st
+ /\ match_env map e' nil rs'.
(** Finally, the correctness condition for the translation of functions
is that the translated RTL function, when applied to the same arguments
- as the original Cminor function, returns the same value and performs
- the same modifications on the memory state. *)
+ as the original CminorSel function, returns the same value, produces
+ the same trace of events, and performs the same modifications on the
+ memory state. *)
Definition transl_function_correct
- (m: mem) (f: Cminor.fundef) (vargs: list val)
- (t: trace) (m':mem) (vres: val) : Prop :=
- forall tf
- (TE: transl_fundef f = Some tf),
- exec_function tge tf vargs m t vres m'.
+ (m: mem) (f: CminorSel.fundef) (vargs: list val)
+ (t: trace) (m': mem) (vres: val) : Prop :=
+ forall cs tf
+ (TE: transl_fundef f = OK tf),
+ star step tge (Callstate cs tf vargs m) t (Returnstate cs vres m').
(** The correctness of the translation is a huge induction over
- the Cminor evaluation derivation for the source program. To keep
+ the CminorSel evaluation derivation for the source program. To keep
the proof manageable, we put each case of the proof in a separate
- lemma. There is one lemma for each Cminor evaluation rule.
- It takes as hypotheses the premises of the Cminor evaluation rule,
+ lemma. There is one lemma for each CminorSel evaluation rule.
+ It takes as hypotheses the premises of the CminorSel evaluation rule,
plus the induction hypotheses, that is, the [transl_expr_correct], etc,
corresponding to the evaluations of sub-expressions or sub-statements. *)
@@ -276,35 +534,22 @@ Lemma transl_expr_Evar_correct:
e!id = Some v ->
transl_expr_correct sp le e m (Evar id) E0 m v.
Proof.
- intros; red; intros. monadInv TE. intro.
- generalize EQ; unfold find_var. caseEq (map_vars map)!id.
- intros r' MV; monadSimpl. subst s0; subst r'.
- generalize (add_move_correct _ _ sp _ _ _ _ rs m TE0).
- intros [rs1 [EX1 [RES1 OTHER1]]].
- exists rs1.
-(* Exec *)
- split. assumption.
-(* Match-env *)
- split. inversion TRG; subst.
- (* Optimized case rd = r *)
- rewrite MV in H3; injection H3; intro; subst r.
- apply match_env_exten with rs.
- intros. case (Reg.eq r rd); intro.
- subst r; assumption. apply OTHER1; assumption.
- assumption.
- (* General case rd is temp *)
- apply match_env_invariant with rs.
- assumption. intros. apply OTHER1. congruence.
-(* Result value *)
- split. rewrite RES1. eauto with rtlg.
-(* Other regs *)
- intros. destruct (Reg.eq rd r0).
- subst r0. inversion TRG; subst.
- congruence.
- byContradiction. tauto.
+ intros; red; intros. inv TE.
+ exploit tr_move_correct; eauto. intros [rs' [A [B C]]].
+ exists rs'; split. eauto.
+ destruct H2 as [D | [E F]].
+ (* optimized case *)
+ subst r.
+ assert (forall r, rs'#r = rs#r).
+ intros. destruct (Reg.eq r rd). subst r. auto. auto.
+ split. eapply match_env_invariant; eauto.
+ split. rewrite B. eapply match_env_find_var; eauto.
auto.
-
- intro; monadSimpl.
+ (* general case *)
+ split. eapply match_env_invariant; eauto.
+ intros. apply C. congruence.
+ split. rewrite B. eapply match_env_find_var; eauto.
+ intros. apply C. intuition congruence.
Qed.
Lemma transl_expr_Eop_correct:
@@ -313,36 +558,25 @@ Lemma transl_expr_Eop_correct:
(v: val),
eval_exprlist ge sp le e m al t m1 vl ->
transl_exprlist_correct sp le e m al t m1 vl ->
- eval_operation ge sp op vl = Some v ->
+ eval_operation ge sp op vl m1 = Some v ->
transl_expr_correct sp le e m (Eop op al) t m1 v.
Proof.
- intros until v. intros EEL TEL EOP. red; intros.
- simpl in TE. monadInv TE. intro EQ1.
- exploit TEL. 2: eauto. eauto with rtlg. eauto. eauto with rtlg.
- intros [rs1 [EX1 [ME1 [RR1 RO1]]]].
+ intros; red; intros. inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RR1 RO1]]]].
exists (rs1#rd <- v).
(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s1. eauto with rtlg.
- apply exec_one; eapply exec_Iop. eauto with rtlg.
+ split. eapply star_right. eexact EX1.
+ eapply exec_Iop; eauto.
subst vl.
- rewrite (@eval_operation_preserved Cminor.fundef RTL.fundef ge tge).
- eexact EOP.
+ rewrite (@eval_operation_preserved CminorSel.fundef RTL.fundef ge tge).
+ auto.
exact symbols_preserved. traceEq.
(* Match-env *)
- split. inversion TRG. eauto with rtlg.
+ split. eauto with rtlg.
(* Result reg *)
split. apply Regmap.gss.
(* Other regs *)
- intros. rewrite Regmap.gso.
- apply RO1. eauto with rtlg.
- destruct (In_dec Reg.eq r l).
- left. elim (alloc_regs_fresh_or_in_map _ _ _ _ _ MWF EQ r i); intro.
- auto. byContradiction; eauto with rtlg.
- right; auto.
- red; intro; subst r.
- elim H0; intro. inversion TRG. contradiction.
- tauto.
+ intros. rewrite Regmap.gso. auto. intuition congruence.
Qed.
Lemma transl_expr_Eload_correct:
@@ -356,30 +590,19 @@ Lemma transl_expr_Eload_correct:
Mem.loadv chunk m1 a = Some v ->
transl_expr_correct sp le e m (Eload chunk addr al) t m1 v.
Proof.
- intros; red; intros. simpl in TE. monadInv TE. intro EQ1. clear TE.
- assert (MWF1: map_wf map s1). eauto with rtlg.
- assert (TRG1: target_regs_ok s1 map al l). eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ _ MWF1 EQ1 ME TRG1).
- intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ intros; red; intros. inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
exists (rs1#rd <- v).
(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s1. eauto with rtlg.
- apply exec_one. eapply exec_Iload. eauto with rtlg.
+ split. eapply star_right. eexact EX1. eapply exec_Iload; eauto.
rewrite RES1. rewrite (@eval_addressing_preserved _ _ ge tge).
- eexact H1. exact symbols_preserved. assumption. traceEq.
+ exact H1. exact symbols_preserved. traceEq.
(* Match-env *)
- split. eapply match_env_update_temp. assumption. inversion TRG. assumption.
+ split. eauto with rtlg.
(* Result *)
split. apply Regmap.gss.
(* Other regs *)
- intros. rewrite Regmap.gso. apply OTHER1.
- eauto with rtlg.
- case (In_dec Reg.eq r l); intro.
- elim (alloc_regs_fresh_or_in_map _ _ _ _ _ MWF EQ r i); intro.
- tauto. byContradiction. eauto with rtlg.
- tauto.
- red; intro; subst r. inversion TRG. tauto.
+ intros. rewrite Regmap.gso. auto. intuition congruence.
Qed.
Lemma transl_expr_Estore_correct:
@@ -397,35 +620,18 @@ Lemma transl_expr_Estore_correct:
t = t1 ** t2 ->
transl_expr_correct sp le e m (Estore chunk addr al b) t m3 v.
Proof.
- intros; red; intros. simpl in TE; monadInv TE. intro EQ2; clear TE.
- assert (MWF2: map_wf map s2).
- apply map_wf_incr with s.
- apply state_incr_trans2 with s0 s1; eauto with rtlg.
- assumption.
- assert (TRG2: target_regs_ok s2 map al l).
- apply target_regs_ok_incr with s0; eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ _ MWF2 EQ2 ME TRG2).
- intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
- assert (MWF1: map_wf map s1). eauto with rtlg.
- assert (TRG1: target_reg_ok s1 map b rd).
- inversion TRG. apply target_reg_other; eauto with rtlg.
- generalize (H2 _ _ _ _ _ _ _ MWF1 EQ1 ME1 TRG1).
- intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ exploit H2; eauto. intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
exists rs2.
(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s2. eauto with rtlg.
- eapply exec_trans. eexact EX2.
- apply exec_instrs_incr with s1. eauto with rtlg.
- apply exec_one. eapply exec_Istore. eauto with rtlg.
- assert (rs2##l = rs1##l).
+ split. eapply star_trans. eexact EX1.
+ eapply star_right. eexact EX2.
+ eapply exec_Istore; eauto.
+ assert (rs2##rl = rs1##rl).
apply list_map_exten. intros r' IN. symmetry. apply OTHER2.
- eauto with rtlg. eauto with rtlg.
- elim (alloc_regs_fresh_or_in_map _ _ _ _ _ MWF EQ r' IN); intro.
- tauto. right. apply sym_not_equal.
- apply valid_fresh_different with s. inversion TRG; assumption.
- assumption.
- rewrite H6; rewrite RES1.
+ right. apply in_or_app. auto.
+ rewrite H5; rewrite RES1.
rewrite (@eval_addressing_preserved _ _ ge tge).
eexact H3. exact symbols_preserved.
rewrite RES2. assumption.
@@ -435,110 +641,52 @@ Proof.
(* Result *)
split. assumption.
(* Other regs *)
- intro r'; intros. transitivity (rs1#r').
- apply OTHER2. apply reg_valid_incr with s; eauto with rtlg.
- assumption.
- apply OTHER1. apply reg_valid_incr with s.
- apply state_incr_trans2 with s0 s1; eauto with rtlg. assumption.
- case (In_dec Reg.eq r' l); intro.
- elim (alloc_regs_fresh_or_in_map _ _ _ _ _ MWF EQ r' i); intro.
- tauto. byContradiction; eauto with rtlg. tauto.
-Qed.
+ intro r'; intros. transitivity (rs1#r').
+ apply OTHER2. intuition.
+ auto.
+Qed.
Lemma transl_expr_Ecall_correct:
forall (sp: val) (le : letenv) (e : env) (m : mem)
(sig : signature) (a : expr) (bl : exprlist) (t t1: trace)
(m1: mem) (t2: trace) (m2 : mem)
(t3: trace) (m3: mem) (vf : val)
- (vargs : list val) (vres : val) (f : Cminor.fundef),
+ (vargs : list val) (vres : val) (f : CminorSel.fundef),
eval_expr ge sp le e m a t1 m1 vf ->
transl_expr_correct sp le e m a t1 m1 vf ->
eval_exprlist ge sp le e m1 bl t2 m2 vargs ->
transl_exprlist_correct sp le e m1 bl t2 m2 vargs ->
Genv.find_funct ge vf = Some f ->
- Cminor.funsig f = sig ->
+ CminorSel.funsig f = sig ->
eval_funcall ge m2 f vargs t3 m3 vres ->
transl_function_correct m2 f vargs t3 m3 vres ->
t = t1 ** t2 ** t3 ->
transl_expr_correct sp le e m (Ecall sig a bl) t m3 vres.
Proof.
- intros. red; simpl; intros.
- monadInv TE. intro EQ3. clear TE.
- assert (MWFa: map_wf map s3).
- apply map_wf_incr with s.
- apply state_incr_trans3 with s0 s1 s2; eauto with rtlg.
- assumption.
- assert (TRGr: target_reg_ok s3 map a r).
- apply target_reg_ok_incr with s0.
- apply state_incr_trans2 with s1 s2; eauto with rtlg.
- eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ _ MWFa EQ3 ME TRGr).
- intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
- clear MWFa TRGr.
- assert (MWFbl: map_wf map s2).
- apply map_wf_incr with s.
- apply state_incr_trans2 with s0 s1; eauto with rtlg.
- assumption.
- assert (TRGl: target_regs_ok s2 map bl l).
- apply target_regs_ok_incr with s1; eauto with rtlg.
- generalize (H2 _ _ _ _ _ _ _ MWFbl EQ2 ME1 TRGl).
- intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
- clear MWFbl TRGl.
-
- generalize (functions_translated vf f H3). intros [tf [TFIND TF]].
- generalize (H6 tf TF). intro EXF.
-
- assert (EX3: exec_instrs tge (st_code s2) sp n rs2 m2
- t3 nd (rs2#rd <- vres) m3).
- apply exec_one. eapply exec_Icall.
- eauto with rtlg. simpl. replace (rs2#r) with vf. eexact TFIND.
- rewrite <- RES1. symmetry. apply OTHER2.
- apply reg_valid_incr with s0; eauto with rtlg.
- assert (MWFs0: map_wf map s0). eauto with rtlg.
- case (In_dec Reg.eq r l); intro.
- elim (alloc_regs_fresh_or_in_map _ _ _ _ _ MWFs0 EQ0 r i); intro.
- tauto. byContradiction. apply valid_fresh_absurd with r s0.
- eauto with rtlg. assumption.
- tauto.
- generalize (sig_transl_function _ _ TF). congruence.
- rewrite RES2. assumption.
-
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ exploit H2; eauto. intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
+ exploit functions_translated; eauto. intros [tf [TFIND TF]].
+ exploit H6; eauto. intro EXF.
exists (rs2#rd <- vres).
(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s3. eauto with rtlg.
- eapply exec_trans. eexact EX2.
- apply exec_instrs_incr with s2. eauto with rtlg.
- eexact EX3. reflexivity. traceEq.
+ split. eapply star_trans. eexact EX1.
+ eapply star_trans. eexact EX2.
+ eapply star_left. eapply exec_Icall; eauto.
+ simpl. rewrite OTHER2. rewrite RES1. eauto. simpl; tauto.
+ eapply sig_transl_function; eauto.
+ eapply star_right. rewrite RES2. eexact EXF.
+ apply exec_return. reflexivity. reflexivity. reflexivity. traceEq.
(* Match env *)
- split. apply match_env_update_temp. assumption.
- inversion TRG. assumption.
+ split. eauto with rtlg.
(* Result *)
split. apply Regmap.gss.
(* Other regs *)
intros.
- rewrite Regmap.gso. transitivity (rs1#r0).
- apply OTHER2.
- apply reg_valid_incr with s.
- apply state_incr_trans2 with s0 s1; eauto with rtlg.
- assumption.
- assert (MWFs0: map_wf map s0). eauto with rtlg.
- case (In_dec Reg.eq r0 l); intro.
- elim (alloc_regs_fresh_or_in_map _ _ _ _ _ MWFs0 EQ0 r0 i); intro.
- tauto. byContradiction. apply valid_fresh_absurd with r0 s0.
- eauto with rtlg. assumption.
- tauto.
- apply OTHER1.
- apply reg_valid_incr with s.
- apply state_incr_trans3 with s0 s1 s2; eauto with rtlg.
- assumption.
- case (Reg.eq r0 r); intro.
- subst r0.
- elim (alloc_reg_fresh_or_in_map _ _ _ _ _ MWF EQ); intro.
- tauto. byContradiction; eauto with rtlg.
- tauto.
- red; intro; subst r0.
- inversion TRG. tauto.
+ rewrite Regmap.gso. transitivity (rs1#r).
+ apply OTHER2. simpl; tauto.
+ apply OTHER1; auto.
+ intuition congruence.
Qed.
Lemma transl_expr_Econdition_correct:
@@ -552,52 +700,20 @@ Lemma transl_expr_Econdition_correct:
t = t1 ** t2 ->
transl_expr_correct sp le e m (Econdition a b c) t m2 v2.
Proof.
- intros; red; intros. simpl in TE; monadInv TE. intro EQ1; clear TE.
-
- assert (MWF1: map_wf map s1).
- apply map_wf_incr with s. eauto with rtlg. assumption.
- generalize (H0 _ _ _ _ _ _ _ MWF1 EQ1 ME).
- intros [rs1 [EX1 [ME1 OTHER1]]].
- destruct v1.
-
- assert (MWF0: map_wf map s0). eauto with rtlg.
- assert (TRG0: target_reg_ok s0 map b rd).
- inversion TRG. apply target_reg_other; eauto with rtlg.
- generalize (H2 _ _ _ _ _ _ _ MWF0 EQ0 ME1 TRG0).
- intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
- exists rs2.
-(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s1. eauto with rtlg.
- eexact EX2. auto.
-(* Match-env *)
- split. assumption.
-(* Result value *)
- split. assumption.
-(* Other regs *)
- intros. transitivity (rs1#r).
- apply OTHER2; auto. eauto with rtlg.
- apply OTHER1; auto. apply reg_valid_incr with s.
- apply state_incr_trans with s0; eauto with rtlg. assumption.
-
- assert (TRGc: target_reg_ok s map c rd).
- inversion TRG. apply target_reg_other; auto.
- generalize (H2 _ _ _ _ _ _ _ MWF EQ ME1 TRGc).
- intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 OTHER1]]].
+ assert (tr_expr code map pr (if v1 then b else c) (if v1 then ntrue else nfalse) nd rd).
+ destruct v1; auto.
+ exploit H2; eauto. intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
exists rs2.
(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s0. eauto with rtlg.
- eexact EX2. auto.
+ split. eapply star_trans. eexact EX1. eexact EX2. auto.
(* Match-env *)
split. assumption.
(* Result value *)
split. assumption.
(* Other regs *)
- intros. transitivity (rs1#r).
- apply OTHER2; auto. eauto with rtlg.
- apply OTHER1; auto. apply reg_valid_incr with s.
- apply state_incr_trans2 with s0 s1; eauto with rtlg. assumption.
+ intros. transitivity (rs1#r); auto.
Qed.
Lemma transl_expr_Elet_correct:
@@ -611,47 +727,25 @@ Lemma transl_expr_Elet_correct:
t = t1 ** t2 ->
transl_expr_correct sp le e m (Elet a b) t m2 v2.
Proof.
- intros; red; intros.
- simpl in TE; monadInv TE. intro EQ1.
- assert (MWF1: map_wf map s1). eauto with rtlg.
- assert (TRG1: target_reg_ok s1 map a r).
- eapply target_reg_other; eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ _ MWF1 EQ1 ME TRG1).
- intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
- assert (MWF2: map_wf (add_letvar map r) s0).
- apply add_letvar_wf; eauto with rtlg.
- assert (ME2: match_env (add_letvar map r) e (v1 :: le) rs1).
- apply match_env_letvar; assumption.
- assert (TRG2: target_reg_ok s0 (add_letvar map r) b rd).
- inversion TRG. apply target_reg_other.
- unfold reg_in_map, add_letvar; simpl. red; intro.
- elim H10; intro. apply H4. left. assumption.
- elim H11; intro. apply valid_fresh_absurd with rd s.
- assumption. rewrite <- H12. eauto with rtlg.
- apply H4. right. assumption.
- eauto with rtlg.
- generalize (H2 _ _ _ _ _ _ _ MWF2 EQ0 ME2 TRG2).
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ assert (map_wf (add_letvar map r)).
+ eapply add_letvar_wf; eauto.
+ exploit H2; eauto. eapply match_env_bind_letvar; eauto.
intros [rs2 [EX2 [ME3 [RES2 OTHER2]]]].
exists rs2.
(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s1. eauto with rtlg. eexact EX2. auto.
+ split. eapply star_trans. eexact EX1. eexact EX2. auto.
(* Match-env *)
- split. apply mk_match_env. exact (me_vars _ _ _ _ ME3).
- generalize (me_letvars _ _ _ _ ME3).
- unfold add_letvar; simpl. intro X; injection X; auto.
+ split. eapply match_env_unbind_letvar; eauto.
(* Result *)
split. assumption.
(* Other regs *)
intros. transitivity (rs1#r0).
- apply OTHER2. eauto with rtlg.
- elim H5; intro. left.
+ apply OTHER2. elim H4; intro; auto.
unfold reg_in_map, add_letvar; simpl.
- unfold reg_in_map in H6; tauto.
- tauto.
- apply OTHER1. eauto with rtlg.
- right. red; intro. apply valid_fresh_absurd with r0 s.
- assumption. rewrite H6. eauto with rtlg.
+ unfold reg_in_map in H5; tauto.
+ auto.
Qed.
Lemma transl_expr_Eletvar_correct:
@@ -660,35 +754,22 @@ Lemma transl_expr_Eletvar_correct:
nth_error le n = Some v ->
transl_expr_correct sp le e m (Eletvar n) E0 m v.
Proof.
- intros; red; intros.
- simpl in TE; monadInv TE. intro EQ1.
- generalize EQ. unfold find_letvar.
- caseEq (nth_error (map_letvars map) n).
- intros r0 NE; monadSimpl. subst s0; subst r0.
- generalize (add_move_correct _ _ sp _ _ _ _ rs m EQ1).
- intros [rs1 [EX1 [RES1 OTHER1]]].
+ intros; red; intros; inv TE.
+ exploit tr_move_correct; eauto. intros [rs1 [EX1 [RES1 OTHER1]]].
exists rs1.
(* Exec *)
- split. exact EX1.
+ split. eexact EX1.
(* Match-env *)
- split. inversion TRG.
- assert (r = rd). congruence.
- subst r. apply match_env_exten with rs.
- intros. case (Reg.eq r rd); intro. subst r; auto. auto. auto.
- apply match_env_invariant with rs. auto.
- intros. apply OTHER1. red;intro;subst r1. contradiction.
+ split. apply match_env_invariant with rs. auto.
+ intros. destruct H2 as [A | [B C]].
+ subst r. destruct (Reg.eq r0 rd). subst r0; auto. auto.
+ apply OTHER1. intuition congruence.
(* Result *)
- split. rewrite RES1.
- generalize H. rewrite <- (me_letvars _ _ _ _ ME).
- change positive with reg.
- rewrite list_map_nth. rewrite NE. simpl. congruence.
+ split. rewrite RES1. eapply match_env_find_letvar; eauto.
(* Other regs *)
- intros. inversion TRG.
- assert (r = rd). congruence. subst r.
- case (Reg.eq r0 rd); intro. subst r0; auto. auto.
- apply OTHER1. red; intro; subst r0. tauto.
-
- intro; monadSimpl.
+ intros. destruct H2 as [A | [B C]].
+ subst r. destruct (Reg.eq r0 rd). subst r0; auto. auto.
+ apply OTHER1. intuition congruence.
Qed.
Lemma transl_expr_Ealloc_correct:
@@ -700,47 +781,35 @@ Lemma transl_expr_Ealloc_correct:
Mem.alloc m1 0 (Int.signed n) = (m2, b) ->
transl_expr_correct sp le e m (Ealloc a) t m2 (Vptr b Int.zero).
Proof.
- intros until b; intros EE TEC ALLOC; red; intros.
- simpl in TE. monadInv TE. intro EQ1.
- assert (TRG': target_reg_ok s1 map a r); eauto with rtlg.
- assert (MWF': map_wf map s1). eauto with rtlg.
- generalize (TEC _ _ _ _ _ _ _ MWF' EQ1 ME TRG').
- intros [rs1 [EX1 [ME1 [RR1 RO1]]]].
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RR1 RO1]]]].
exists (rs1#rd <- (Vptr b Int.zero)).
(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s1. eauto with rtlg.
- apply exec_one; eapply exec_Ialloc. eauto with rtlg.
+ split. eapply star_right. eexact EX1.
+ eapply exec_Ialloc. eauto with rtlg.
eexact RR1. assumption. traceEq.
(* Match-env *)
- split. inversion TRG. eauto with rtlg.
+ split. eauto with rtlg.
(* Result *)
split. apply Regmap.gss.
(* Other regs *)
- intros. rewrite Regmap.gso.
- apply RO1. eauto with rtlg.
- case (Reg.eq r0 r); intro.
- subst r0. left. elim (alloc_reg_fresh_or_in_map _ _ _ _ _ MWF EQ); intro.
- auto. byContradiction; eauto with rtlg.
- right; assumption.
- elim H0; intro. red; intro. subst r0. inversion TRG. contradiction.
- auto.
+ intros. rewrite Regmap.gso. auto. intuition congruence.
Qed.
Lemma transl_condition_CEtrue_correct:
forall (sp: val) (le : letenv) (e : env) (m : mem),
transl_condition_correct sp le e m CEtrue E0 m true.
Proof.
- intros; red; intros. simpl in TE; monadInv TE. subst ns.
- exists rs. split. apply exec_refl. split. auto. auto.
+ intros; red; intros; inv TE.
+ exists rs. split. apply star_refl. split. auto. auto.
Qed.
Lemma transl_condition_CEfalse_correct:
forall (sp: val) (le : letenv) (e : env) (m : mem),
transl_condition_correct sp le e m CEfalse E0 m false.
Proof.
- intros; red; intros. simpl in TE; monadInv TE. subst ns.
- exists rs. split. apply exec_refl. split. auto. auto.
+ intros; red; intros; inv TE.
+ exists rs. split. apply star_refl. split. auto. auto.
Qed.
Lemma transl_condition_CEcond_correct:
@@ -749,33 +818,24 @@ Lemma transl_condition_CEcond_correct:
(m1 : mem) (vl : list val) (b : bool),
eval_exprlist ge sp le e m al t1 m1 vl ->
transl_exprlist_correct sp le e m al t1 m1 vl ->
- eval_condition cond vl = Some b ->
+ eval_condition cond vl m1 = Some b ->
transl_condition_correct sp le e m (CEcond cond al) t1 m1 b.
Proof.
- intros; red; intros. simpl in TE; monadInv TE. intro EQ1; clear TE.
- assert (MWF1: map_wf map s1). eauto with rtlg.
- assert (TRG: target_regs_ok s1 map al l). eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ _ MWF1 EQ1 ME TRG).
- intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
exists rs1.
(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s1. eauto with rtlg.
- apply exec_one.
+ split. eapply star_right. eexact EX1.
destruct b.
- eapply exec_Icond_true. eauto with rtlg.
+ eapply exec_Icond_true; eauto.
rewrite RES1. assumption.
- eapply exec_Icond_false. eauto with rtlg.
+ eapply exec_Icond_false; eauto.
rewrite RES1. assumption.
traceEq.
(* Match-env *)
split. assumption.
(* Regs *)
- intros. apply OTHER1. eauto with rtlg.
- case (In_dec Reg.eq r l); intro.
- elim (alloc_regs_fresh_or_in_map _ _ _ _ _ MWF EQ r i); intro.
- tauto. byContradiction; eauto with rtlg.
- tauto.
+ auto.
Qed.
Lemma transl_condition_CEcondition_correct:
@@ -789,47 +849,31 @@ Lemma transl_condition_CEcondition_correct:
t = t1 ** t2 ->
transl_condition_correct sp le e m (CEcondition a b c) t m2 vb2.
Proof.
- intros; red; intros. simpl in TE; monadInv TE. intro EQ1; clear TE.
- assert (MWF1: map_wf map s1). eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ _ MWF1 EQ1 ME).
- intros [rs1 [EX1 [ME1 OTHER1]]].
- destruct vb1.
-
- assert (MWF0: map_wf map s0). eauto with rtlg.
- generalize (H2 _ _ _ _ _ _ _ MWF0 EQ0 ME1).
- intros [rs2 [EX2 [ME2 OTHER2]]].
- exists rs2.
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s1. eauto with rtlg.
- eexact EX2. auto.
- split. assumption.
- intros. transitivity (rs1#r).
- apply OTHER2; eauto with rtlg.
- apply OTHER1; eauto with rtlg.
-
- generalize (H2 _ _ _ _ _ _ _ MWF EQ ME1).
- intros [rs2 [EX2 [ME2 OTHER2]]].
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 OTHER1]]].
+ assert (tr_condition code map pr (if vb1 then b else c)
+ (if vb1 then ntrue' else nfalse') ntrue nfalse).
+ destruct vb1; auto.
+ exploit H2; eauto. intros [rs2 [EX2 [ME2 OTHER2]]].
exists rs2.
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s0. eauto with rtlg.
- eexact EX2. auto.
- split. assumption.
- intros. transitivity (rs1#r).
- apply OTHER2; eauto with rtlg.
- apply OTHER1; eauto with rtlg.
+(* Execution *)
+ split. eapply star_trans. eexact EX1. eexact EX2. auto.
+(* Match-env *)
+ split. auto.
+(* Regs *)
+ intros. transitivity (rs1#r); auto.
Qed.
Lemma transl_exprlist_Enil_correct:
forall (sp: val) (le : letenv) (e : env) (m : mem),
transl_exprlist_correct sp le e m Enil E0 m nil.
Proof.
- intros; red; intros.
- generalize TE. simpl. destruct rl; monadSimpl.
- subst s'; subst ns. exists rs.
- split. apply exec_refl.
+ intros; red; intros; inv TE.
+ exists rs.
+ split. apply star_refl.
split. assumption.
split. reflexivity.
- intros. reflexivity.
+ auto.
Qed.
Lemma transl_exprlist_Econs_correct:
@@ -843,93 +887,90 @@ Lemma transl_exprlist_Econs_correct:
t = t1 ** t2 ->
transl_exprlist_correct sp le e m (Econs a bl) t m2 (v :: vl).
Proof.
- intros. red. intros.
- inversion TRG.
- rewrite <- H10 in TE. simpl in TE. monadInv TE. intro EQ1.
- assert (MWF1: map_wf map s1); eauto with rtlg.
- assert (TRG1: target_reg_ok s1 map a r); eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ _ MWF1 EQ1 ME TRG1).
- intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
- generalize (H2 _ _ _ _ _ _ _ MWF EQ ME1 H11).
- intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ exploit H2; eauto. intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
exists rs2.
(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s1. eauto with rtlg.
- eexact EX2. auto.
+ split. eapply star_trans. eexact EX1. eexact EX2. auto.
(* Match-env *)
split. assumption.
(* Results *)
- split. simpl. rewrite RES2. rewrite OTHER2. rewrite RES1.
- reflexivity.
- eauto with rtlg.
- eauto with rtlg.
+ split. simpl. rewrite RES2. rewrite OTHER2. rewrite RES1. auto.
+ simpl; tauto.
(* Other regs *)
- simpl. intros.
- transitivity (rs1#r0).
- apply OTHER2; auto. tauto.
- apply OTHER1; auto. eauto with rtlg.
- elim H13; intro. left; assumption. right; apply sym_not_equal; tauto.
+ intros. transitivity (rs1#r).
+ apply OTHER2; auto. simpl; tauto.
+ apply OTHER1; auto.
Qed.
Lemma transl_funcall_internal_correct:
- forall (m : mem) (f : Cminor.function)
+ forall (m : mem) (f : CminorSel.function)
(vargs : list val) (m1 : mem) (sp : block) (e : env) (t : trace)
- (e2 : env) (m2 : mem) (out : outcome) (vres : val),
+ (e2 : env) (m2 : mem) (out: outcome) (vres : val),
Mem.alloc m 0 (fn_stackspace f) = (m1, sp) ->
- set_locals (fn_vars f) (set_params vargs (Cminor.fn_params f)) = e ->
+ set_locals (fn_vars f) (set_params vargs (CminorSel.fn_params f)) = e ->
exec_stmt ge (Vptr sp Int.zero) e m1 (fn_body f) t e2 m2 out ->
transl_stmt_correct (Vptr sp Int.zero) e m1 (fn_body f) t e2 m2 out ->
- outcome_result_value out f.(Cminor.fn_sig).(sig_res) vres ->
- transl_function_correct m (Internal f)
- vargs t (Mem.free m2 sp) vres.
+ outcome_result_value out f.(CminorSel.fn_sig).(sig_res) vres ->
+ transl_function_correct m (Internal f) vargs t
+ (outcome_free_mem out m2 sp) vres.
Proof.
intros; red; intros.
- generalize TE. unfold transl_fundef, transl_function; simpl.
- caseEq (transl_fun f init_state).
- intros; discriminate.
- intros ns s. unfold transl_fun. monadSimpl.
- subst ns. intros EQ4. injection EQ4; intro TF; clear EQ4.
- subst s4.
-
- pose (rs := init_regs vargs x).
- assert (ME: match_env y0 e nil rs).
+ generalize TE; simpl. caseEq (transl_function f); simpl. 2: congruence.
+ intros tfi EQ1 EQ2. injection EQ2; clear EQ2; intro EQ2.
+ assert (TR: tr_function f tfi). apply transl_function_charact; auto.
+ rewrite <- EQ2. inversion TR. subst f0.
+
+ pose (rs := init_regs vargs rparams).
+ assert (ME: match_env map2 e nil rs).
rewrite <- H0. unfold rs.
- eapply match_init_env_init_reg; eauto.
+ eapply match_init_env_init_reg; eauto.
+
+ assert (MWF: map_wf map2).
+ assert (map_valid init_mapping init_state) by apply init_mapping_valid.
+ exploit (add_vars_valid (CminorSel.fn_params f)); eauto. intros [A B].
+ eapply add_vars_wf; eauto. eapply add_vars_wf; eauto. apply init_mapping_wf.
+
+ exploit H2; eauto. intros [rs' [st [OUT [EX ME']]]].
+
+ eapply star_left.
+ eapply exec_function_internal; eauto. simpl.
+ inversion OUT; clear OUT; subst out st; simpl in H3; simpl.
+
+ (* Out_normal *)
+ unfold ret_reg in H6. destruct (sig_res (CminorSel.fn_sig f)). contradiction.
+ subst vres orret.
+ eapply star_right. unfold rs in EX. eexact EX.
+ change Vundef with (regmap_optget None Vundef rs').
+ apply exec_Ireturn. auto. reflexivity.
+
+ (* Out_exit *)
+ contradiction.
+
+ (* Out_return None *)
+ subst orret.
+ unfold ret_reg in H8. destruct (sig_res (CminorSel.fn_sig f)). contradiction.
+ subst vres.
+ eapply star_right. unfold rs in EX. eexact EX.
+ change Vundef with (regmap_optget None Vundef rs').
+ apply exec_Ireturn. auto.
+ reflexivity.
- assert (OUT: outcome_node out n nil n n).
- red. generalize H3. unfold outcome_result_value.
- destruct out; contradiction || auto.
-
- assert (MWF1: map_wf y0 s1).
- eapply add_vars_wf. eexact EQ0.
- eapply add_vars_wf. eexact EQ.
- apply init_mapping_wf.
-
- assert (MWF: map_wf y0 s3).
- apply map_wf_incr with s1. apply state_incr_trans with s2; eauto with rtlg.
- assumption.
-
- set (rr := ret_reg (Cminor.fn_sig f) r) in *.
- assert (RRG: return_reg_ok s3 y0 rr).
- apply return_reg_ok_incr with s2. eauto with rtlg.
- unfold rr; apply new_reg_return_ok with s1; assumption.
-
- generalize (H2 _ _ _ _ _ _ _ _ _ rs MWF EQ3 ME OUT RRG).
- intros [rs1 [EX1 [ME1 MR1]]].
-
- rewrite <- TF. apply exec_funct_internal with m1 n rs1 rr; simpl.
- assumption.
- exact EX1.
- apply instr_at_incr with s3.
- eauto with rtlg. discriminate. eauto with rtlg.
- generalize MR1. unfold match_return_outcome.
- generalize H3. unfold outcome_result_value.
- unfold rr, ret_reg; destruct (sig_res (Cminor.fn_sig f)).
- unfold regmap_optget. destruct out; try contradiction.
- destruct o; try contradiction. intros; congruence.
- unfold regmap_optget. destruct out; contradiction||auto.
- destruct o; contradiction||auto.
+ (* Out_return Some *)
+ subst orret.
+ unfold ret_reg in H8. unfold ret_reg in H9.
+ destruct (sig_res (CminorSel.fn_sig f)). inversion H9.
+ subst vres.
+ eapply star_right. unfold rs in EX. eexact EX.
+ replace v with (regmap_optget (Some rret) Vundef rs').
+ apply exec_Ireturn. auto.
+ simpl. congruence.
+ reflexivity.
+ contradiction.
+
+ (* a tail call *)
+ subst v. rewrite E0_right. auto. traceEq.
Qed.
Lemma transl_funcall_external_correct:
@@ -939,17 +980,27 @@ Lemma transl_funcall_external_correct:
Proof.
intros; red; intros. unfold transl_function in TE; simpl in TE.
inversion TE; subst tf.
- apply exec_funct_external. auto.
+ apply star_one. apply exec_function_external. auto.
Qed.
Lemma transl_stmt_Sskip_correct:
forall (sp: val) (e : env) (m : mem),
transl_stmt_correct sp e m Sskip E0 e m Out_normal.
Proof.
- intros; red; intros. simpl in TE. monadInv TE.
- subst s'; subst ns.
- simpl in OUT. subst ncont.
- exists rs. simpl. intuition. apply exec_refl.
+ intros; red; intros; inv TE.
+ exists rs; econstructor.
+ split. constructor.
+ split. apply star_refl.
+ auto.
+Qed.
+
+Remark state_for_outcome_stop:
+ forall ncont1 ncont2 nexits nret rret cs code sp rs m out st,
+ state_for_outcome ncont1 nexits nret rret cs code sp rs m out st ->
+ out <> Out_normal ->
+ state_for_outcome ncont2 nexits nret rret cs code sp rs m out st.
+Proof.
+ intros. inv H; congruence || econstructor; eauto.
Qed.
Lemma transl_stmt_Sseq_continue_correct:
@@ -963,22 +1014,13 @@ Lemma transl_stmt_Sseq_continue_correct:
t = t1 ** t2 ->
transl_stmt_correct sp e m (Sseq s1 s2) t e2 m2 out.
Proof.
- intros; red; intros. simpl in TE; monadInv TE. intro EQ0.
- assert (MWF1: map_wf map s0). eauto with rtlg.
- assert (OUTs: outcome_node Out_normal n nexits nret n).
- simpl. auto.
- assert (RRG1: return_reg_ok s0 map rret). eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ _ _ _ _ MWF1 EQ0 ME OUTs RRG1).
- intros [rs1 [EX1 [ME1 MR1]]].
- generalize (H2 _ _ _ _ _ _ _ _ _ _ MWF EQ ME1 OUT RRG).
- intros [rs2 [EX2 [ME2 MR2]]].
- exists rs2.
-(* Exec *)
- split. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s0. eauto with rtlg.
- eexact EX2. auto.
-(* Match-env + return *)
- tauto.
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [st1 [OUT1 [EX1 ME1]]]]. inv OUT1.
+ exploit H2; eauto. intros [rs2 [st2 [OUT2 [EX2 ME2]]]].
+ exists rs2; exists st2.
+ split. eauto.
+ split. eapply star_trans; eauto.
+ auto.
Qed.
Lemma transl_stmt_Sseq_stop_correct:
@@ -989,13 +1031,11 @@ Lemma transl_stmt_Sseq_stop_correct:
out <> Out_normal ->
transl_stmt_correct sp e m (Sseq s1 s2) t e1 m1 out.
Proof.
- intros; red; intros.
- simpl in TE; monadInv TE. intro EQ0; clear TE.
- assert (MWF1: map_wf map s0). eauto with rtlg.
- assert (OUTs: outcome_node out n nexits nret nd).
- destruct out; simpl; auto. tauto.
- assert (RRG1: return_reg_ok s0 map rret). eauto with rtlg.
- exact (H0 _ _ _ _ _ _ _ _ _ _ MWF1 EQ0 ME OUTs RRG1).
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [st1 [OUT1 [EX1 ME1]]]].
+ exists rs1; exists st1.
+ split. eapply state_for_outcome_stop; eauto.
+ auto.
Qed.
Lemma transl_stmt_Sexpr_correct:
@@ -1005,14 +1045,11 @@ Lemma transl_stmt_Sexpr_correct:
transl_expr_correct sp nil e m a t m1 v ->
transl_stmt_correct sp e m (Sexpr a) t e m1 Out_normal.
Proof.
- intros; red; intros.
- simpl in OUT. subst nd.
- unfold transl_stmt in TE. monadInv TE. intro EQ1.
- assert (MWF0: map_wf map s0). eauto with rtlg.
- assert (TRG: target_reg_ok s0 map a r). eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ _ MWF0 EQ1 ME TRG).
- intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
- exists rs1; simpl; tauto.
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ exists rs1; econstructor.
+ split. constructor.
+ eauto.
Qed.
Lemma transl_stmt_Sassign_correct:
@@ -1022,26 +1059,17 @@ Lemma transl_stmt_Sassign_correct:
transl_expr_correct sp nil e m a t m1 v ->
transl_stmt_correct sp e m (Sassign id a) t (PTree.set id v e) m1 Out_normal.
Proof.
- intros; red; intros.
- simpl in TE. monadInv TE. intro EQ2.
- assert (MWF0: map_wf map s2).
- apply map_wf_incr with s. eauto 6 with rtlg. auto.
- assert (TRGa: target_reg_ok s2 map a r0). eauto 6 with rtlg.
- generalize (H0 _ _ _ _ _ _ _ MWF0 EQ2 ME TRGa).
- intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
- generalize (add_move_correct _ _ sp _ _ _ _ rs1 m1 EQ1).
- intros [rs2 [EX2 [RES2 OTHER2]]].
- exists rs2.
-(* Exec *)
- split. inversion OUT; subst. eapply exec_trans. eexact EX1.
- apply exec_instrs_incr with s2. eauto with rtlg.
- eexact EX2. traceEq.
-(* Match-env *)
- split.
- apply match_env_update_var with rs1 r s s0; auto.
- congruence.
-(* Outcome *)
- simpl; auto.
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ exploit tr_move_correct; eauto. intros [rs2 [EX2 [RES2 OTHER2]]].
+ exists rs2; econstructor.
+ split. constructor.
+ split. eapply star_trans. eexact EX1. eexact EX2. traceEq.
+ apply match_env_invariant with (rs1#rv <- v).
+ apply match_env_update_var; auto.
+ intros. rewrite Regmap.gsspec. destruct (peq r rv).
+ subst r. congruence.
+ auto.
Qed.
Lemma transl_stmt_Sifthenelse_correct:
@@ -1055,45 +1083,15 @@ Lemma transl_stmt_Sifthenelse_correct:
t = t1 ** t2 ->
transl_stmt_correct sp e m (Sifthenelse a s1 s2) t e2 m2 out.
Proof.
- intros; red; intros until rs; intro MWF.
- simpl. case (more_likely a s1 s2); monadSimpl; intro EQ2; intros.
- assert (MWF1: map_wf map s3). eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ rs MWF1 EQ2 ME).
- intros [rs1 [EX1 [ME1 OTHER1]]].
- destruct v1.
- assert (MWF0: map_wf map s0). eauto with rtlg.
- assert (RRG0: return_reg_ok s0 map rret). eauto with rtlg.
- generalize (H2 _ _ _ _ _ _ _ _ _ _ MWF0 EQ0 ME1 OUT RRG0).
- intros [rs2 [EX2 [ME2 MRE2]]].
- exists rs2. split.
- eapply exec_trans. eexact EX1. apply exec_instrs_incr with s3.
- eauto with rtlg. eexact EX2. auto.
- tauto.
- generalize (H2 _ _ _ _ _ _ _ _ _ _ MWF EQ ME1 OUT RRG).
- intros [rs2 [EX2 [ME2 MRE2]]].
- exists rs2. split.
- eapply exec_trans. eexact EX1. apply exec_instrs_incr with s0.
- eauto with rtlg. eexact EX2. auto.
- tauto.
-
- assert (MWF1: map_wf map s3). eauto with rtlg.
- generalize (H0 _ _ _ _ _ _ rs MWF1 EQ2 ME).
- intros [rs1 [EX1 [ME1 OTHER1]]].
- destruct v1.
- generalize (H2 _ _ _ _ _ _ _ _ _ _ MWF EQ ME1 OUT RRG).
- intros [rs2 [EX2 [ME2 MRE2]]].
- exists rs2. split.
- eapply exec_trans. eexact EX1. apply exec_instrs_incr with s0.
- eauto with rtlg. eexact EX2. auto.
- tauto.
- assert (MWF0: map_wf map s0). eauto with rtlg.
- assert (RRG0: return_reg_ok s0 map rret). eauto with rtlg.
- generalize (H2 _ _ _ _ _ _ _ _ _ _ MWF0 EQ0 ME1 OUT RRG0).
- intros [rs2 [EX2 [ME2 MRE2]]].
- exists rs2. split.
- eapply exec_trans. eexact EX1. apply exec_instrs_incr with s3.
- eauto with rtlg. eexact EX2. auto.
- tauto.
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 OTHER1]]].
+ assert (tr_stmt code map (if v1 then s1 else s2) (if v1 then ntrue else nfalse) ncont nexits nret rret).
+ destruct v1; auto.
+ exploit H2; eauto. intros [rs2 [st2 [OUT2 [EX2 ME2]]]].
+ exists rs2; exists st2.
+ split. eauto.
+ split. eapply star_trans. eexact EX1. eexact EX2. auto.
+ auto.
Qed.
Lemma transl_stmt_Sloop_loop_correct:
@@ -1107,34 +1105,15 @@ Lemma transl_stmt_Sloop_loop_correct:
t = t1 ** t2 ->
transl_stmt_correct sp e m (Sloop sl) t e2 m2 out.
Proof.
- intros; red; intros.
- generalize TE. simpl. monadSimpl. subst s2; subst n0. intros.
- assert (MWF0: map_wf map s0). apply map_wf_incr with s.
- eapply reserve_instr_incr; eauto.
- assumption.
- assert (OUT0: outcome_node Out_normal n nexits nret n).
- unfold outcome_node. auto.
- assert (RRG0: return_reg_ok s0 map rret).
- apply return_reg_ok_incr with s.
- eapply reserve_instr_incr; eauto.
- assumption.
- generalize (H0 _ _ _ _ _ _ _ _ _ _ MWF0 EQ0 ME OUT0 RRG0).
- intros [rs1 [EX1 [ME1 MR1]]].
- generalize (H2 _ _ _ _ _ _ _ _ _ _ MWF TE ME1 OUT RRG).
- intros [rs2 [EX2 [ME2 MR2]]].
- exists rs2.
- split. eapply exec_trans.
- apply exec_instrs_extends with s1.
- eapply update_instr_extends.
- eexact EQ. eauto with rtlg. eexact EQ1. eexact EX1.
- apply exec_trans with E0 ns rs1 m1 t2.
- apply exec_one. apply exec_Inop.
- generalize EQ1. unfold update_instr.
- case (plt n (st_nextnode s1)); intro; monadSimpl.
- rewrite <- H5. simpl. apply PTree.gss.
- exact EX2.
- reflexivity. traceEq.
- tauto.
+ intros; red; intros; inversion TE. subst.
+ exploit H0; eauto. intros [rs1 [st1 [OUT1 [EX1 ME1]]]]. inv OUT1.
+ exploit H2; eauto. intros [rs2 [st2 [OUT2 [EX2 ME2]]]].
+ exists rs2; exists st2.
+ split. eauto.
+ split. eapply star_trans. eexact EX1.
+ eapply star_left. apply exec_Inop; eauto. eexact EX2.
+ reflexivity. traceEq.
+ auto.
Qed.
Lemma transl_stmt_Sloop_stop_correct:
@@ -1145,25 +1124,12 @@ Lemma transl_stmt_Sloop_stop_correct:
out <> Out_normal ->
transl_stmt_correct sp e m (Sloop sl) t e1 m1 out.
Proof.
- intros; red; intros.
- simpl in TE. monadInv TE. subst s2; subst n0.
- assert (MWF0: map_wf map s0). apply map_wf_incr with s.
- eapply reserve_instr_incr; eauto. assumption.
- assert (OUT0: outcome_node out n nexits nret nd).
- generalize OUT. unfold outcome_node.
- destruct out; auto. elim H1; auto.
- assert (RRG0: return_reg_ok s0 map rret).
- apply return_reg_ok_incr with s.
- eapply reserve_instr_incr; eauto.
- assumption.
- generalize (H0 _ _ _ _ _ _ _ _ _ _ MWF0 EQ0 ME OUT0 RRG0).
- intros [rs1 [EX1 [ME1 MR1]]].
- exists rs1. split.
- apply exec_instrs_extends with s1.
- eapply update_instr_extends.
- eexact EQ. eauto with rtlg. eexact EQ1. eexact EX1.
- tauto.
-Qed.
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [st1 [OUT1 [EX1 ME1]]]].
+ exists rs1; exists st1.
+ split. eapply state_for_outcome_stop; eauto.
+ auto.
+Qed.
Lemma transl_stmt_Sblock_correct:
forall (sp: val) (e : env) (m : mem) (sl : stmt) (t: trace)
@@ -1172,65 +1138,59 @@ Lemma transl_stmt_Sblock_correct:
transl_stmt_correct sp e m sl t e1 m1 out ->
transl_stmt_correct sp e m (Sblock sl) t e1 m1 (outcome_block out).
Proof.
- intros; red; intros. simpl in TE.
- assert (OUT': outcome_node out ncont (ncont :: nexits) nret nd).
- generalize OUT. unfold outcome_node, outcome_block.
- destruct out.
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [st1 [OUT1 [EX1 ME1]]]].
+ exists rs1; exists st1.
+ split. inv OUT1; simpl; try (econstructor; eauto).
+ destruct n; simpl in H1.
+ inv H1. constructor.
+ constructor. auto.
auto.
- destruct n. simpl. intro; unfold value; congruence.
- simpl. auto.
- auto.
- generalize (H0 _ _ _ _ _ _ _ _ _ _ MWF TE ME OUT' RRG).
- intros [rs1 [EX1 [ME1 MR1]]].
- exists rs1.
- split. assumption.
- split. assumption.
- generalize MR1. unfold match_return_outcome, outcome_block.
- destruct out; auto.
- destruct n; simpl; auto.
-Qed.
-
-Lemma transl_exit_correct:
- forall nexits ex s nd s',
- transl_exit nexits ex s = OK nd s' ->
- nth_error nexits ex = Some nd.
-Proof.
- intros until s'. unfold transl_exit.
- case (nth_error nexits ex); intros; simplify_eq H; congruence.
Qed.
Lemma transl_stmt_Sexit_correct:
forall (sp: val) (e : env) (m : mem) (n : nat),
transl_stmt_correct sp e m (Sexit n) E0 e m (Out_exit n).
Proof.
- intros; red; intros.
- simpl in TE. simpl in OUT.
- generalize (transl_exit_correct _ _ _ _ _ TE); intro.
- assert (ns = nd). congruence. subst ns.
- exists rs. simpl. intuition. apply exec_refl.
+ intros; red; intros; inv TE.
+ exists rs; econstructor.
+ split. econstructor; eauto.
+ split. apply star_refl.
+ auto.
Qed.
Lemma transl_switch_correct:
- forall sp rs m r i nexits nd default cases s ns s',
- transl_switch r nexits cases default s = OK ns s' ->
- nth_error nexits (switch_target i default cases) = Some nd ->
+ forall cs sp rs m i code r nexits t ns,
+ tr_switch code r nexits t ns ->
rs#r = Vint i ->
- exec_instrs tge s'.(st_code) sp ns rs m E0 nd rs m.
+ exists nd,
+ star step tge (State cs code sp ns rs m) E0 (State cs code sp nd rs m) /\
+ nth_error nexits (comptree_match i t) = Some nd.
Proof.
- induction cases; simpl; intros.
- generalize (transl_exit_correct _ _ _ _ _ H). intros.
- assert (ns = nd). congruence. subst ns. apply exec_refl.
- destruct a as [key1 exit1]. monadInv H. clear H. intro EQ1.
- caseEq (Int.eq i key1); intro IEQ; rewrite IEQ in H0.
- (* i = key1 *)
- apply exec_trans with E0 n0 rs m E0. apply exec_one.
- eapply exec_Icond_true. eauto with rtlg. simpl. rewrite H1. congruence.
- generalize (transl_exit_correct _ _ _ _ _ EQ0); intro.
- assert (n0 = nd). congruence. subst n0. apply exec_refl. traceEq.
- (* i <> key1 *)
- apply exec_trans with E0 n rs m E0. apply exec_one.
- eapply exec_Icond_false. eauto with rtlg. simpl. rewrite H1. congruence.
- apply exec_instrs_incr with s0; eauto with rtlg. traceEq.
+ induction 1; intros; simpl.
+ exists n. split. apply star_refl. auto.
+
+ caseEq (Int.eq i key); intros.
+ exists nfound; split.
+ apply star_one. eapply exec_Icond_true; eauto.
+ simpl. rewrite H2. congruence. auto.
+ exploit IHtr_switch; eauto. intros [nd [EX MATCH]].
+ exists nd; split.
+ eapply star_step. eapply exec_Icond_false; eauto.
+ simpl. rewrite H2. congruence. eexact EX. traceEq.
+ auto.
+
+ caseEq (Int.ltu i key); intros.
+ exploit IHtr_switch1; eauto. intros [nd [EX MATCH]].
+ exists nd; split.
+ eapply star_step. eapply exec_Icond_true; eauto.
+ simpl. rewrite H2. congruence. eexact EX. traceEq.
+ auto.
+ exploit IHtr_switch2; eauto. intros [nd [EX MATCH]].
+ exists nd; split.
+ eapply star_step. eapply exec_Icond_false; eauto.
+ simpl. rewrite H2. congruence. eexact EX. traceEq.
+ auto.
Qed.
Lemma transl_stmt_Sswitch_correct:
@@ -1242,32 +1202,25 @@ Lemma transl_stmt_Sswitch_correct:
transl_stmt_correct sp e m (Sswitch a cases default) t1 e m1
(Out_exit (switch_target n default cases)).
Proof.
- intros; red; intros. monadInv TE. clear TE; intros EQ1.
- simpl in OUT.
- assert (state_incr s s1). eauto with rtlg.
-
- red in H0.
- assert (MWF1: map_wf map s1). eauto with rtlg.
- assert (TRG1: target_reg_ok s1 map a r). eauto with rtlg.
- destruct (H0 _ _ _ _ _ _ _ MWF1 EQ1 ME TRG1)
- as [rs' [EXEC1 [ME1 [RES1 OTHER1]]]].
- simpl. exists rs'.
- (* execution *)
- split. eapply exec_trans. eexact EXEC1.
- apply exec_instrs_incr with s1. eauto with rtlg.
- eapply transl_switch_correct; eauto. traceEq.
- (* match_env & match_reg *)
- tauto.
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ exploit transl_switch_correct; eauto. intros [nd [EX2 MO2]].
+ exists rs1; econstructor.
+ split. econstructor.
+ rewrite (validate_switch_correct _ _ _ H4 n). eauto.
+ split. eapply star_trans. eexact EX1. eexact EX2. traceEq.
+ auto.
Qed.
Lemma transl_stmt_Sreturn_none_correct:
forall (sp: val) (e : env) (m : mem),
transl_stmt_correct sp e m (Sreturn None) E0 e m (Out_return None).
Proof.
- intros; red; intros. generalize TE. simpl.
- destruct rret; monadSimpl.
- simpl in OUT. subst ns; subst nret.
- exists rs. intuition. apply exec_refl.
+ intros; red; intros; inv TE.
+ exists rs; econstructor.
+ split. constructor. auto.
+ split. apply star_refl.
+ auto.
Qed.
Lemma transl_stmt_Sreturn_some_correct:
@@ -1277,33 +1230,59 @@ Lemma transl_stmt_Sreturn_some_correct:
transl_expr_correct sp nil e m a t m1 v ->
transl_stmt_correct sp e m (Sreturn (Some a)) t e m1 (Out_return (Some v)).
Proof.
- intros; red; intros. generalize TE; simpl.
- destruct rret. intro EQ.
- assert (TRG: target_reg_ok s map a r).
- inversion RRG. apply target_reg_other; auto.
- generalize (H0 _ _ _ _ _ _ _ MWF EQ ME TRG).
- intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
- simpl in OUT. subst nd. exists rs1. tauto.
-
- monadSimpl.
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ exists rs1; econstructor.
+ split. econstructor. reflexivity. auto.
+ eauto.
+Qed.
+
+Lemma transl_stmt_Stailcall_correct:
+ forall (sp : block) (e : env) (m : mem) (sig : signature) (a : expr)
+ (bl : exprlist) (t t1 : trace) (m1 : mem) (t2 : trace) (m2 : mem)
+ (t3 : trace) (m3 : mem) (vf : val) (vargs : list val) (vres : val)
+ (f : CminorSel.fundef),
+ eval_expr ge (Vptr sp Int.zero) nil e m a t1 m1 vf ->
+ transl_expr_correct (Vptr sp Int.zero) nil e m a t1 m1 vf ->
+ eval_exprlist ge (Vptr sp Int.zero) nil e m1 bl t2 m2 vargs ->
+ transl_exprlist_correct (Vptr sp Int.zero) nil e m1 bl t2 m2 vargs ->
+ Genv.find_funct ge vf = Some f ->
+ CminorSel.funsig f = sig ->
+ eval_funcall ge (free m2 sp) f vargs t3 m3 vres ->
+ transl_function_correct (free m2 sp) f vargs t3 m3 vres ->
+ t = t1 ** t2 ** t3 ->
+ transl_stmt_correct (Vptr sp Int.zero) e m (Stailcall sig a bl)
+ t e m3 (Out_tailcall_return vres).
+Proof.
+ intros; red; intros; inv TE.
+ exploit H0; eauto. intros [rs1 [EX1 [ME1 [RES1 OTHER1]]]].
+ exploit H2; eauto. intros [rs2 [EX2 [ME2 [RES2 OTHER2]]]].
+ exploit functions_translated; eauto. intros [tf [TFIND TF]].
+ exploit H6; eauto. intro EXF.
+ exists rs2; econstructor.
+ split. constructor.
+ split.
+ eapply star_trans. eexact EX1.
+ eapply star_trans. eexact EX2.
+ eapply star_step.
+ eapply exec_Itailcall; eauto.
+ simpl. rewrite OTHER2. rewrite RES1. eauto. simpl; tauto.
+ eapply sig_transl_function; eauto.
+ rewrite RES2. eexact EXF.
+ reflexivity. reflexivity. traceEq.
+ auto.
Qed.
(** The correctness of the translation then follows by application
- of the mutual induction principle for Cminor evaluation derivations
+ of the mutual induction principle for CminorSel evaluation derivations
to the lemmas above. *)
-Scheme eval_expr_ind_5 := Minimality for eval_expr Sort Prop
- with eval_condexpr_ind_5 := Minimality for eval_condexpr Sort Prop
- with eval_exprlist_ind_5 := Minimality for eval_exprlist Sort Prop
- with eval_funcall_ind_5 := Minimality for eval_funcall Sort Prop
- with exec_stmt_ind_5 := Minimality for exec_stmt Sort Prop.
-
Theorem transl_function_correctness:
forall m f vargs t m' vres,
eval_funcall ge m f vargs t m' vres ->
transl_function_correct m f vargs t m' vres.
Proof
- (eval_funcall_ind_5 ge
+ (eval_funcall_ind5 ge
transl_expr_correct
transl_condition_correct
transl_exprlist_correct
@@ -1339,26 +1318,35 @@ Proof
transl_stmt_Sexit_correct
transl_stmt_Sswitch_correct
transl_stmt_Sreturn_none_correct
- transl_stmt_Sreturn_some_correct).
+ transl_stmt_Sreturn_some_correct
+ transl_stmt_Stailcall_correct).
+
+Require Import Smallstep.
+
+(** The correctness of the translation follows: if the original CminorSel
+ program executes with trace [t] and exit code [r], then the generated
+ RTL program terminates with the same trace and exit code. *)
Theorem transl_program_correct:
- forall (t: trace) (r: val),
- Cminor.exec_program prog t r ->
- RTL.exec_program tprog t r.
+ forall (t: trace) (r: int),
+ CminorSel.exec_program prog t (Vint r) ->
+ RTL.exec_program tprog (Terminates t r).
Proof.
intros t r [b [f [m [SYMB [FUNC [SIG EVAL]]]]]].
generalize (function_ptr_translated _ _ FUNC).
intros [tf [TFIND TRANSLF]].
- red; exists b; exists tf; exists m.
- split. rewrite symbols_preserved.
- replace (prog_main tprog) with (prog_main prog).
- assumption.
+ exploit transl_function_correctness; eauto. intro EX.
+ econstructor.
+ econstructor.
+ rewrite symbols_preserved.
+ replace (prog_main tprog) with (prog_main prog). eauto.
symmetry; apply transform_partial_program_main with transl_fundef.
exact TRANSL.
- split. exact TFIND.
- split. generalize (sig_transl_function _ _ TRANSLF). congruence.
+ eexact TFIND.
+ generalize (sig_transl_function _ _ TRANSLF). congruence.
unfold fundef; rewrite (Genv.init_mem_transf_partial transl_fundef prog TRANSL).
- exact (transl_function_correctness _ _ _ _ _ _ EVAL _ TRANSLF).
+ eexact EX.
+ constructor.
Qed.
End CORRECTNESS.
diff --git a/backend/RTLgenproof1.v b/backend/RTLgenproof1.v
deleted file mode 100644
index 8e12e79882fd022045a1e810989a63cb01716ba5..0000000000000000000000000000000000000000
--- a/backend/RTLgenproof1.v
+++ /dev/null
@@ -1,1367 +0,0 @@
-(** Correctness proof for RTL generation: auxiliary results. *)
-
-Require Import Coqlib.
-Require Import Maps.
-Require Import AST.
-Require Import Integers.
-Require Import Values.
-Require Import Events.
-Require Import Mem.
-Require Import Globalenvs.
-Require Import Op.
-Require Import Registers.
-Require Import Cminor.
-Require Import RTL.
-Require Import RTLgen.
-
-(** * Reasoning about monadic computations *)
-
-(** The tactics below simplify hypotheses of the form [f ... = OK x s]
- where [f] is a monadic computation. For instance, the hypothesis
- [(do x <- a; b) s = OK y s'] will generate the additional witnesses
- [x], [s1] and the additional hypotheses
- [a s = OK x s1] and [b x s1 = OK y s'], reflecting the fact that
- both monadic computations [a] and [b] succeeded.
-*)
-
-Ltac monadSimpl1 :=
- match goal with
- | [ |- (bind ?F ?G ?S = OK ?X ?S') -> _ ] =>
- unfold bind at 1;
- generalize (refl_equal (F S));
- pattern (F S) at -1 in |- *;
- case (F S);
- [ intro; intro; discriminate
- | (let s := fresh "s" in
- (let EQ := fresh "EQ" in
- (intro; intros s EQ;
- try monadSimpl1))) ]
- | [ |- (bind2 ?F ?G ?S = OK ?X ?S') -> _ ] =>
- unfold bind2 at 1; unfold bind at 1;
- generalize (refl_equal (F S));
- pattern (F S) at -1 in |- *;
- case (F S);
- [ intro; intro; discriminate
- | let xy := fresh "xy" in
- (let x := fresh "x" in
- (let y := fresh "y" in
- (let s := fresh "s" in
- (let EQ := fresh "EQ" in
- (intros xy s EQ; destruct xy as [x y]; simpl;
- try monadSimpl1))))) ]
- | [ |- (error _ _ = OK _ _) -> _ ] =>
- unfold error; monadSimpl1
- | [ |- (ret _ _ = OK _ _) -> _ ] =>
- unfold ret; monadSimpl1
- | [ |- (Error _ = OK _ _) -> _ ] =>
- intro; discriminate
- | [ |- (OK _ _ = OK _ _) -> _ ] =>
- let h := fresh "H" in
- (intro h; injection h; intro; intro; clear h)
- end.
-
-Ltac monadSimpl :=
- match goal with
- | [ |- (bind ?F ?G ?S = OK ?X ?S') -> _ ] => monadSimpl1
- | [ |- (bind2 ?F ?G ?S = OK ?X ?S') -> _ ] => monadSimpl1
- | [ |- (error _ _ = OK _ _) -> _ ] => monadSimpl1
- | [ |- (ret _ _ = OK _ _) -> _ ] => monadSimpl1
- | [ |- (Error _ = OK _ _) -> _ ] => monadSimpl1
- | [ |- (OK _ _ = OK _ _) -> _ ] => monadSimpl1
- | [ |- (?F _ _ _ _ _ _ _ = OK _ _) -> _ ] => unfold F; monadSimpl1
- | [ |- (?F _ _ _ _ _ _ = OK _ _) -> _ ] => unfold F; monadSimpl1
- | [ |- (?F _ _ _ _ _ = OK _ _) -> _ ] => unfold F; monadSimpl1
- | [ |- (?F _ _ _ _ = OK _ _) -> _ ] => unfold F; monadSimpl1
- | [ |- (?F _ _ _ = OK _ _) -> _ ] => unfold F; monadSimpl1
- | [ |- (?F _ _ = OK _ _) -> _ ] => unfold F; monadSimpl1
- | [ |- (?F _ = OK _ _) -> _ ] => unfold F; monadSimpl1
- end.
-
-Ltac monadInv H :=
- generalize H; monadSimpl.
-
-(** * Monotonicity properties of the state *)
-
-(** Operations over the global state satisfy a crucial monotonicity property:
- nodes are only added to the CFG, but never removed nor their instructions
- changed; similarly, fresh nodes and fresh registers are only consumed,
- but never reused. This property is captured by the following predicate
- over states, which we show is a partial order. *)
-
-Inductive state_incr: state -> state -> Prop :=
- state_incr_intro:
- forall (s1 s2: state),
- Ple s1.(st_nextnode) s2.(st_nextnode) ->
- Ple s1.(st_nextreg) s2.(st_nextreg) ->
- (forall pc, Plt pc s1.(st_nextnode) -> s2.(st_code)!pc = s1.(st_code)!pc) ->
- state_incr s1 s2.
-
-Lemma instr_at_incr:
- forall s1 s2 n i,
- s1.(st_code)!n = i -> i <> None -> state_incr s1 s2 ->
- s2.(st_code)!n = i.
-Proof.
- intros. inversion H1.
- rewrite <- H. apply H4. elim (st_wf s1 n); intro.
- assumption. elim H0. congruence.
-Qed.
-
-Lemma state_incr_refl:
- forall s, state_incr s s.
-Proof.
- intros. apply state_incr_intro.
- apply Ple_refl. apply Ple_refl. intros; auto.
-Qed.
-Hint Resolve state_incr_refl: rtlg.
-
-Lemma state_incr_trans:
- forall s1 s2 s3, state_incr s1 s2 -> state_incr s2 s3 -> state_incr s1 s3.
-Proof.
- intros. inversion H. inversion H0. apply state_incr_intro.
- apply Ple_trans with (st_nextnode s2); assumption.
- apply Ple_trans with (st_nextreg s2); assumption.
- intros. transitivity (s2.(st_code)!pc).
- apply H8. apply Plt_Ple_trans with s1.(st_nextnode); auto.
- apply H3; auto.
-Qed.
-Hint Resolve state_incr_trans: rtlg.
-
-Lemma state_incr_trans2:
- forall s1 s2 s3 s4,
- state_incr s1 s2 -> state_incr s2 s3 -> state_incr s3 s4 ->
- state_incr s1 s4.
-Proof.
- intros; eauto with rtlg.
-Qed.
-
-Lemma state_incr_trans3:
- forall s1 s2 s3 s4 s5,
- state_incr s1 s2 -> state_incr s2 s3 -> state_incr s3 s4 -> state_incr s4 s5 ->
- state_incr s1 s5.
-Proof.
- intros; eauto with rtlg.
-Qed.
-
-Lemma state_incr_trans4:
- forall s1 s2 s3 s4 s5 s6,
- state_incr s1 s2 -> state_incr s2 s3 -> state_incr s3 s4 ->
- state_incr s4 s5 -> state_incr s5 s6 ->
- state_incr s1 s6.
-Proof.
- intros; eauto with rtlg.
-Qed.
-
-Lemma state_incr_trans5:
- forall s1 s2 s3 s4 s5 s6 s7,
- state_incr s1 s2 -> state_incr s2 s3 -> state_incr s3 s4 ->
- state_incr s4 s5 -> state_incr s5 s6 -> state_incr s6 s7 ->
- state_incr s1 s7.
-Proof.
- intros; eauto 6 with rtlg.
-Qed.
-
-Lemma state_incr_trans6:
- forall s1 s2 s3 s4 s5 s6 s7 s8,
- state_incr s1 s2 -> state_incr s2 s3 -> state_incr s3 s4 ->
- state_incr s4 s5 -> state_incr s5 s6 -> state_incr s6 s7 ->
- state_incr s7 s8 -> state_incr s1 s8.
-Proof.
- intros; eauto 7 with rtlg.
-Qed.
-
-(** The following relation between two states is a weaker version of
- [state_incr]. It permits changing the contents at an already reserved
- graph node, but only from [None] to [Some i]. *)
-
-Definition state_extends (s1 s2: state): Prop :=
- forall pc,
- s1.(st_code)!pc = None \/ s2.(st_code)!pc = s1.(st_code)!pc.
-
-Lemma state_incr_extends:
- forall s1 s2,
- state_incr s1 s2 -> state_extends s1 s2.
-Proof.
- unfold state_extends; intros. inversion H.
- case (plt pc s1.(st_nextnode)); intro.
- right; apply H2; auto.
- left. elim (s1.(st_wf) pc); intro.
- elim (n H5). auto.
-Qed.
-Hint Resolve state_incr_extends.
-
-(** A crucial property of states is the following: if an RTL execution
- is possible (does not get stuck) in the CFG of a given state [s1]
- the same execution is possible and leads to the same results in
- the CFG of any state [s2] that extends [s1] in the sense of the
- [state_extends] predicate. *)
-
-Section EXEC_INSTR_EXTENDS.
-
-Variable s1 s2: state.
-Hypothesis EXT: state_extends s1 s2.
-
-Lemma exec_instr_not_halt:
- forall ge c sp pc rs m t pc' rs' m',
- exec_instr ge c sp pc rs m t pc' rs' m' -> c!pc <> None.
-Proof.
- induction 1; rewrite H; discriminate.
-Qed.
-
-Lemma exec_instr_in_s2:
- forall ge sp pc rs m t pc' rs' m',
- exec_instr ge s1.(st_code) sp pc rs m t pc' rs' m' ->
- s2.(st_code)!pc = s1.(st_code)!pc.
-Proof.
- intros.
- elim (EXT pc); intro.
- elim (exec_instr_not_halt _ _ _ _ _ _ _ _ _ _ H H0).
- assumption.
-Qed.
-
-Lemma exec_instr_extends_rec:
- forall ge c sp pc rs m t pc' rs' m',
- exec_instr ge c sp pc rs m t pc' rs' m' ->
- forall c', c!pc = c'!pc ->
- exec_instr ge c' sp pc rs m t pc' rs' m'.
-Proof.
- induction 1; intros.
- apply exec_Inop. congruence.
- apply exec_Iop with op args. congruence. auto.
- apply exec_Iload with chunk addr args a. congruence. auto. auto.
- apply exec_Istore with chunk addr args src a.
- congruence. auto. auto.
- apply exec_Icall with sig ros args f; auto. congruence.
- apply exec_Ialloc with arg sz; auto. congruence.
- apply exec_Icond_true with cond args ifnot; auto. congruence.
- apply exec_Icond_false with cond args ifso; auto. congruence.
-Qed.
-
-Lemma exec_instr_extends:
- forall ge sp pc rs m t pc' rs' m',
- exec_instr ge s1.(st_code) sp pc rs m t pc' rs' m' ->
- exec_instr ge s2.(st_code) sp pc rs m t pc' rs' m'.
-Proof.
- intros.
- apply exec_instr_extends_rec with (st_code s1).
- assumption.
- symmetry. eapply exec_instr_in_s2. eexact H.
-Qed.
-
-Lemma exec_instrs_extends_rec:
- forall ge c sp pc rs m t pc' rs' m',
- exec_instrs ge c sp pc rs m t pc' rs' m' ->
- c = s1.(st_code) ->
- exec_instrs ge s2.(st_code) sp pc rs m t pc' rs' m'.
-Proof.
- induction 1; intros.
- apply exec_refl.
- apply exec_one. apply exec_instr_extends; auto. rewrite <- H0; auto.
- apply exec_trans with t1 pc2 rs2 m2 t2; auto.
-Qed.
-
-Lemma exec_instrs_extends:
- forall ge sp pc rs m t pc' rs' m',
- exec_instrs ge s1.(st_code) sp pc rs m t pc' rs' m' ->
- exec_instrs ge s2.(st_code) sp pc rs m t pc' rs' m'.
-Proof.
- intros.
- apply exec_instrs_extends_rec with (st_code s1); auto.
-Qed.
-
-End EXEC_INSTR_EXTENDS.
-
-(** Since [state_incr s1 s2] implies [state_extends s1 s2], we also have
- that any RTL execution possible in the CFG of [s1] is also possible
- in the CFG of [s2], provided that [state_incr s1 s2].
- In particular, any RTL execution that is possible in a partially
- constructed CFG remains possible in the final CFG obtained at
- the end of the translation of the current function. *)
-
-Section EXEC_INSTR_INCR.
-
-Variable s1 s2: state.
-Hypothesis INCR: state_incr s1 s2.
-
-Lemma exec_instr_incr:
- forall ge sp pc rs m t pc' rs' m',
- exec_instr ge s1.(st_code) sp pc rs m t pc' rs' m' ->
- exec_instr ge s2.(st_code) sp pc rs m t pc' rs' m'.
-Proof.
- intros.
- apply exec_instr_extends with s1.
- apply state_incr_extends; auto.
- auto.
-Qed.
-
-Lemma exec_instrs_incr:
- forall ge sp pc rs m t pc' rs' m',
- exec_instrs ge s1.(st_code) sp pc rs m t pc' rs' m' ->
- exec_instrs ge s2.(st_code) sp pc rs m t pc' rs' m'.
-Proof.
- intros.
- apply exec_instrs_extends with s1.
- apply state_incr_extends; auto.
- auto.
-Qed.
-
-End EXEC_INSTR_INCR.
-
-(** * Validity and freshness of registers *)
-
-(** An RTL pseudo-register is valid in a given state if it was created
- earlier, that is, it is less than the next fresh register of the state.
- Otherwise, the pseudo-register is said to be fresh. *)
-
-Definition reg_valid (r: reg) (s: state) : Prop :=
- Plt r s.(st_nextreg).
-
-Definition reg_fresh (r: reg) (s: state) : Prop :=
- ~(Plt r s.(st_nextreg)).
-
-Lemma valid_fresh_absurd:
- forall r s, reg_valid r s -> reg_fresh r s -> False.
-Proof.
- intros r s. unfold reg_valid, reg_fresh; case r; tauto.
-Qed.
-Hint Resolve valid_fresh_absurd: rtlg.
-
-Lemma valid_fresh_different:
- forall r1 r2 s, reg_valid r1 s -> reg_fresh r2 s -> r1 <> r2.
-Proof.
- unfold not; intros. subst r2. eauto with rtlg.
-Qed.
-Hint Resolve valid_fresh_different: rtlg.
-
-Lemma reg_valid_incr:
- forall r s1 s2, state_incr s1 s2 -> reg_valid r s1 -> reg_valid r s2.
-Proof.
- intros r s1 s2 INCR.
- inversion INCR.
- unfold reg_valid. intros; apply Plt_Ple_trans with (st_nextreg s1); auto.
-Qed.
-Hint Resolve reg_valid_incr: rtlg.
-
-Lemma reg_fresh_decr:
- forall r s1 s2, state_incr s1 s2 -> reg_fresh r s2 -> reg_fresh r s1.
-Proof.
- intros r s1 s2 INCR. inversion INCR.
- unfold reg_fresh; unfold not; intros.
- apply H4. apply Plt_Ple_trans with (st_nextreg s1); auto.
-Qed.
-Hint Resolve reg_fresh_decr: rtlg.
-
-(** * Well-formedness of compilation environments *)
-
-(** A compilation environment (mapping) is well-formed in a given state if
- the following properties hold:
-- The registers associated with Cminor local variables and let-bound variables
- are valid in the state.
-- Two distinct Cminor local variables are mapped to distinct pseudo-registers.
-- A Cminor local variable and a let-bound variable are mapped to
- distinct pseudo-registers.
-*)
-
-Record map_wf (m: mapping) (s: state) : Prop :=
- mk_map_wf {
- map_wf_var_valid:
- (forall id r, m.(map_vars)!id = Some r -> reg_valid r s);
- map_wf_letvar_valid:
- (forall r, In r m.(map_letvars) -> reg_valid r s);
- map_wf_inj:
- (forall id1 id2 r,
- m.(map_vars)!id1 = Some r -> m.(map_vars)!id2 = Some r -> id1 = id2);
- map_wf_disj:
- (forall id r,
- m.(map_vars)!id = Some r -> In r m.(map_letvars) -> False)
- }.
-Hint Resolve map_wf_var_valid
- map_wf_letvar_valid
- map_wf_inj map_wf_disj: rtlg.
-
-Lemma map_wf_incr:
- forall s1 s2 m,
- state_incr s1 s2 -> map_wf m s1 -> map_wf m s2.
-Proof.
- intros. apply mk_map_wf; intros; eauto with rtlg.
-Qed.
-Hint Resolve map_wf_incr: rtlg.
-
-(** A register is ``in'' a mapping if it is associated with a Cminor
- local or let-bound variable. *)
-
-Definition reg_in_map (m: mapping) (r: reg) : Prop :=
- (exists id, m.(map_vars)!id = Some r) \/ In r m.(map_letvars).
-
-Lemma reg_in_map_valid:
- forall m s r,
- map_wf m s -> reg_in_map m r -> reg_valid r s.
-Proof.
- intros. elim H0.
- intros [id EQ]. eauto with rtlg.
- intro IN. eauto with rtlg.
-Qed.
-Hint Resolve reg_in_map_valid: rtlg.
-
-(** * Properties of basic operations over the state *)
-
-(** Properties of [add_instr]. *)
-
-Lemma add_instr_incr:
- forall s1 s2 i n,
- add_instr i s1 = OK n s2 -> state_incr s1 s2.
-Proof.
- intros until n; monadSimpl.
- subst s2; apply state_incr_intro; simpl.
- apply Ple_succ.
- apply Ple_refl.
- intros. apply PTree.gso; apply Plt_ne; auto.
-Qed.
-Hint Resolve add_instr_incr: rtlg.
-
-Lemma add_instr_at:
- forall s1 s2 i n,
- add_instr i s1 = OK n s2 -> s2.(st_code)!n = Some i.
-Proof.
- intros until n; monadSimpl.
- subst n; subst s2; simpl. apply PTree.gss.
-Qed.
-Hint Resolve add_instr_at.
-
-(** Properties of [reserve_instr] and [update_instr]. *)
-
-Lemma reserve_instr_incr:
- forall s1 s2 n,
- reserve_instr s1 = OK n s2 -> state_incr s1 s2.
-Proof.
- intros until n; monadSimpl. subst s2.
- apply state_incr_intro; simpl.
- apply Ple_succ.
- apply Ple_refl.
- auto.
-Qed.
-
-Lemma update_instr_incr:
- forall s1 s2 s3 s4 i n t,
- reserve_instr s1 = OK n s2 ->
- state_incr s2 s3 ->
- update_instr n i s3 = OK t s4 ->
- state_incr s1 s4.
-Proof.
- intros.
- monadInv H.
- generalize H1; unfold update_instr.
- case (plt n (st_nextnode s3)); intro.
- monadSimpl. inversion H0.
- subst s4; apply state_incr_intro; simpl.
- apply Plt_Ple. apply Plt_Ple_trans with (st_nextnode s2).
- subst s2; simpl; apply Plt_succ. assumption.
- rewrite <- H3 in H7; simpl in H7. assumption.
- intros. rewrite PTree.gso.
- rewrite <- H3 in H8; simpl in H8. apply H8.
- apply Plt_trans_succ; assumption.
- subst n; apply Plt_ne; assumption.
- intros; discriminate.
-Qed.
-
-Lemma update_instr_extends:
- forall s1 s2 s3 s4 i n t,
- reserve_instr s1 = OK n s2 ->
- state_incr s2 s3 ->
- update_instr n i s3 = OK t s4 ->
- state_extends s3 s4.
-Proof.
- intros.
- monadInv H.
- red; intros.
- case (peq pc n); intro.
- subst pc. left. inversion H0. rewrite H6.
- rewrite <- H3; simpl.
- elim (s1.(st_wf) n); intro.
- rewrite <- H4 in H9. elim (Plt_strict _ H9).
- auto.
- rewrite <- H4. rewrite <- H3; simpl. apply Plt_succ.
- generalize H1; unfold update_instr.
- case (plt n s3.(st_nextnode)); intro; monadSimpl.
- right; rewrite <- H5; simpl. apply PTree.gso; auto.
-Qed.
-
-(** Properties of [new_reg]. *)
-
-Lemma new_reg_incr:
- forall s1 s2 r, new_reg s1 = OK r s2 -> state_incr s1 s2.
-Proof.
- intros until r. monadSimpl.
- subst s2; apply state_incr_intro; simpl.
- apply Ple_refl. apply Ple_succ. auto.
-Qed.
-Hint Resolve new_reg_incr: rtlg.
-
-Lemma new_reg_valid:
- forall s1 s2 r,
- new_reg s1 = OK r s2 -> reg_valid r s2.
-Proof.
- intros until r. monadSimpl. subst s2; subst r.
- unfold reg_valid; unfold reg_valid; simpl.
- apply Plt_succ.
-Qed.
-Hint Resolve new_reg_valid: rtlg.
-
-Lemma new_reg_fresh:
- forall s1 s2 r,
- new_reg s1 = OK r s2 -> reg_fresh r s1.
-Proof.
- intros until r. monadSimpl. subst s2; subst r.
- unfold reg_fresh; simpl.
- exact (Plt_strict _).
-Qed.
-Hint Resolve new_reg_fresh: rtlg.
-
-Lemma new_reg_not_in_map:
- forall s1 s2 m r,
- new_reg s1 = OK r s2 -> map_wf m s1 -> ~(reg_in_map m r).
-Proof.
- unfold not; intros; eauto with rtlg.
-Qed.
-Hint Resolve new_reg_not_in_map: rtlg.
-
-(** * Properties of operations over compilation environments *)
-
-Lemma init_mapping_wf:
- forall s, map_wf init_mapping s.
-Proof.
- intro. unfold init_mapping; apply mk_map_wf; simpl; intros.
- rewrite PTree.gempty in H; discriminate.
- contradiction.
- rewrite PTree.gempty in H; discriminate.
- tauto.
-Qed.
-
-(** Properties of [find_var]. *)
-
-Lemma find_var_incr:
- forall s1 s2 map name r,
- find_var map name s1 = OK r s2 -> state_incr s1 s2.
-Proof.
- intros until r. unfold find_var.
- case (map_vars map)!name.
- intro; monadSimpl. subst s2; auto with rtlg.
- monadSimpl.
-Qed.
-Hint Resolve find_var_incr: rtlg.
-
-Lemma find_var_in_map:
- forall s1 s2 map name r,
- find_var map name s1 = OK r s2 -> map_wf map s1 -> reg_in_map map r.
-Proof.
- intros until r. unfold find_var; caseEq (map.(map_vars)!name).
- intros r0 eq. monadSimpl; intros. subst r0.
- left. exists name; auto.
- intro; monadSimpl.
-Qed.
-Hint Resolve find_var_in_map: rtlg.
-
-Lemma find_var_valid:
- forall s1 s2 map name r,
- find_var map name s1 = OK r s2 -> map_wf map s1 -> reg_valid r s1.
-Proof.
- eauto with rtlg.
-Qed.
-Hint Resolve find_var_valid: rtlg.
-
-
-(** Properties of [find_letvar]. *)
-
-Lemma find_letvar_incr:
- forall s1 s2 map idx r,
- find_letvar map idx s1 = OK r s2 -> state_incr s1 s2.
-Proof.
- intros until r. unfold find_letvar.
- case (nth_error (map_letvars map) idx).
- intro; monadSimpl. subst s2; auto with rtlg.
- monadSimpl.
-Qed.
-Hint Resolve find_letvar_incr: rtlg.
-
-Lemma find_letvar_in_map:
- forall s1 s2 map idx r,
- find_letvar map idx s1 = OK r s2 -> map_wf map s1 -> reg_in_map map r.
-Proof.
- intros until r. unfold find_letvar.
- caseEq (nth_error (map_letvars map) idx).
- intros r0 EQ; monadSimpl. intros. right.
- subst r0; apply nth_error_in with idx; auto.
- intro; monadSimpl.
-Qed.
-Hint Resolve find_letvar_in_map: rtlg.
-
-Lemma find_letvar_valid:
- forall s1 s2 map idx r,
- find_letvar map idx s1 = OK r s2 -> map_wf map s1 -> reg_valid r s1.
-Proof.
- eauto with rtlg.
-Qed.
-Hint Resolve find_letvar_valid: rtlg.
-
-(** Properties of [add_var]. *)
-
-Lemma add_var_valid:
- forall s1 s2 map1 map2 name r,
- add_var map1 name s1 = OK (r, map2) s2 -> reg_valid r s2.
-Proof.
- intros until r. monadSimpl. intro. subst r0; subst s.
- eauto with rtlg.
-Qed.
-
-Lemma add_var_incr:
- forall s1 s2 map name rm,
- add_var map name s1 = OK rm s2 -> state_incr s1 s2.
-Proof.
- intros until rm; monadSimpl. subst s2. eauto with rtlg.
-Qed.
-Hint Resolve add_var_incr: rtlg.
-
-Lemma add_var_wf:
- forall s1 s2 map name r map',
- add_var map name s1 = OK (r,map') s2 -> map_wf map s1 -> map_wf map' s2.
-Proof.
- intros until map'; monadSimpl; intros.
- subst r0; subst s; subst map'; apply mk_map_wf; simpl.
-
- intros id r'. rewrite PTree.gsspec.
- case (peq id name); intros.
- injection H; intros; subst r'. eauto with rtlg.
- eauto with rtlg.
- eauto with rtlg.
-
- intros id1 id2 r'.
- repeat (rewrite PTree.gsspec).
- case (peq id1 name); case (peq id2 name); intros.
- congruence.
- rewrite <- H in H0. byContradiction; eauto with rtlg.
- rewrite <- H0 in H. byContradiction; eauto with rtlg.
- eauto with rtlg.
-
- intros id r'. case (peq id name); intro.
- subst id. rewrite PTree.gss. intro E; injection E; intro; subst r'.
- intro; eauto with rtlg.
-
- rewrite PTree.gso; auto. eauto with rtlg.
-Qed.
-Hint Resolve add_var_wf: rtlg.
-
-Lemma add_var_find:
- forall s1 s2 map name r map',
- add_var map name s1 = OK (r,map') s2 -> map'.(map_vars)!name = Some r.
-Proof.
- intros until map'.
- monadSimpl.
- intro; subst r0.
- subst map'; simpl in |- *.
- apply PTree.gss.
-Qed.
-
-Lemma add_vars_incr:
- forall names s1 s2 map r,
- add_vars map names s1 = OK r s2 -> state_incr s1 s2.
-Proof.
- induction names; simpl.
- intros until r; monadSimpl; intros. subst s2; eauto with rtlg.
- intros until r; monadSimpl; intros.
- subst s0; eauto with rtlg.
-Qed.
-
-Lemma add_vars_valid:
- forall namel s1 s2 map1 map2 rl,
- add_vars map1 namel s1 = OK (rl, map2) s2 ->
- forall r, In r rl -> reg_valid r s2.
-Proof.
- induction namel; simpl; intros.
- monadInv H. intro. subst rl. elim H0.
- monadInv H. intro EQ1. subst rl; subst s0; subst y0. elim H0.
- intro; subst r. eapply add_var_valid. eexact EQ0.
- intro. apply reg_valid_incr with s. eauto with rtlg.
- eauto.
-Qed.
-
-Lemma add_vars_wf:
- forall names s1 s2 map map' rl,
- add_vars map names s1 = OK (rl,map') s2 ->
- map_wf map s1 -> map_wf map' s2.
-Proof.
- induction names; simpl.
- intros until rl; monadSimpl; intros.
- subst s2; subst map'; assumption.
- intros until rl; monadSimpl; intros. subst y0; subst s0.
- eapply add_var_wf. eexact EQ0.
- eapply IHnames. eexact EQ. auto.
-Qed.
-Hint Resolve add_vars_wf: rtlg.
-
-Lemma add_var_letenv:
- forall map1 i s1 r map2 s2,
- add_var map1 i s1 = OK (r, map2) s2 ->
- map2.(map_letvars) = map1.(map_letvars).
-Proof.
- intros until s2. monadSimpl. intro. subst map2; reflexivity.
-Qed.
-
-(** Properties of [add_letvar]. *)
-
-Lemma add_letvar_wf:
- forall map s r,
- map_wf map s ->
- reg_valid r s ->
- ~(reg_in_map map r) ->
- map_wf (add_letvar map r) s.
-Proof.
- intros. unfold add_letvar; apply mk_map_wf; simpl.
- exact (map_wf_var_valid map s H).
- intros r' [EQ| IN].
- subst r'; assumption.
- eapply map_wf_letvar_valid; eauto.
- exact (map_wf_inj map s H).
- intros. elim H3; intro.
- subst r0. apply H1. left. exists id; auto.
- eapply map_wf_disj; eauto.
-Qed.
-
-(** * Properties of [alloc_reg] and [alloc_regs] *)
-
-Lemma alloc_reg_incr:
- forall a s1 s2 map r,
- alloc_reg map a s1 = OK r s2 -> state_incr s1 s2.
-Proof.
- intros until r. unfold alloc_reg.
- case a; eauto with rtlg.
-Qed.
-Hint Resolve alloc_reg_incr: rtlg.
-
-Lemma alloc_reg_valid:
- forall a s1 s2 map r,
- map_wf map s1 ->
- alloc_reg map a s1 = OK r s2 -> reg_valid r s2.
-Proof.
- intros until r. unfold alloc_reg.
- case a; eauto with rtlg.
-Qed.
-Hint Resolve alloc_reg_valid: rtlg.
-
-Lemma alloc_reg_fresh_or_in_map:
- forall map a s r s',
- map_wf map s ->
- alloc_reg map a s = OK r s' ->
- reg_in_map map r \/ reg_fresh r s.
-Proof.
- intros until s'. unfold alloc_reg.
- destruct a; intros; try (right; eauto with rtlg; fail).
- left; eauto with rtlg.
- left; eauto with rtlg.
-Qed.
-
-Lemma add_vars_letenv:
- forall il map1 s1 rl map2 s2,
- add_vars map1 il s1 = OK (rl, map2) s2 ->
- map2.(map_letvars) = map1.(map_letvars).
-Proof.
- induction il; simpl; intros.
- monadInv H. intro. subst map2; reflexivity.
- monadInv H. intro EQ1. transitivity (map_letvars y).
- subst y0. eapply add_var_letenv; eauto.
- eauto.
-Qed.
-
-(** A register is an adequate target for holding the value of an
- expression if
-- either the register is associated with a Cminor let-bound variable
- or a Cminor local variable;
-- or the register is valid and not associated with any Cminor variable. *)
-
-Inductive target_reg_ok: state -> mapping -> expr -> reg -> Prop :=
- | target_reg_var:
- forall s map id r,
- map.(map_vars)!id = Some r ->
- target_reg_ok s map (Evar id) r
- | target_reg_letvar:
- forall s map idx r,
- nth_error map.(map_letvars) idx = Some r ->
- target_reg_ok s map (Eletvar idx) r
- | target_reg_other:
- forall s map a r,
- ~(reg_in_map map r) ->
- reg_valid r s ->
- target_reg_ok s map a r.
-
-Lemma target_reg_ok_incr:
- forall s1 s2 map e r,
- state_incr s1 s2 ->
- target_reg_ok s1 map e r ->
- target_reg_ok s2 map e r.
-Proof.
- intros. inversion H0.
- apply target_reg_var; auto.
- apply target_reg_letvar; auto.
- apply target_reg_other; eauto with rtlg.
-Qed.
-Hint Resolve target_reg_ok_incr: rtlg.
-
-Lemma target_reg_valid:
- forall s map e r,
- map_wf map s ->
- target_reg_ok s map e r ->
- reg_valid r s.
-Proof.
- intros. inversion H0; eauto with rtlg coqlib.
-Qed.
-Hint Resolve target_reg_valid: rtlg.
-
-Lemma alloc_reg_target_ok:
- forall a s1 s2 map r,
- map_wf map s1 ->
- alloc_reg map a s1 = OK r s2 ->
- target_reg_ok s2 map a r.
-Proof.
- intros until r; intro MWF. unfold alloc_reg.
- case a; intros; try (eapply target_reg_other; eauto with rtlg; fail).
- apply target_reg_var.
- generalize H; unfold find_var.
- case (map_vars map)!i.
- intro. monadSimpl. congruence.
- monadSimpl.
- apply target_reg_letvar.
- generalize H. unfold find_letvar.
- case (nth_error (map_letvars map) n).
- intro; monadSimpl; congruence.
- monadSimpl.
-Qed.
-Hint Resolve alloc_reg_target_ok: rtlg.
-
-Lemma alloc_regs_incr:
- forall al s1 s2 map rl,
- alloc_regs map al s1 = OK rl s2 -> state_incr s1 s2.
-Proof.
- induction al; simpl; intros.
- monadInv H. subst s2. eauto with rtlg.
- monadInv H. subst s2. eauto with rtlg.
-Qed.
-Hint Resolve alloc_regs_incr: rtlg.
-
-Lemma alloc_regs_valid:
- forall al s1 s2 map rl,
- map_wf map s1 ->
- alloc_regs map al s1 = OK rl s2 ->
- forall r, In r rl -> reg_valid r s2.
-Proof.
- induction al; simpl; intros.
- monadInv H0. subst rl. elim H1.
- monadInv H0. subst rl; subst s0.
- elim H1; intro.
- subst r0. eauto with rtlg.
- eauto with rtlg.
-Qed.
-Hint Resolve alloc_regs_valid: rtlg.
-
-Lemma alloc_regs_fresh_or_in_map:
- forall map al s rl s',
- map_wf map s ->
- alloc_regs map al s = OK rl s' ->
- forall r, In r rl -> reg_in_map map r \/ reg_fresh r s.
-Proof.
- induction al; simpl; intros.
- monadInv H0. subst rl. elim H1.
- monadInv H0. subst rl. elim (in_inv H1); intro.
- subst r.
- assert (MWF: map_wf map s0). eauto with rtlg.
- elim (alloc_reg_fresh_or_in_map map e s0 r0 s1 MWF EQ0); intro.
- left; assumption. right; eauto with rtlg.
- eauto with rtlg.
-Qed.
-
-Inductive target_regs_ok: state -> mapping -> exprlist -> list reg -> Prop :=
- | target_regs_nil:
- forall s map,
- target_regs_ok s map Enil nil
- | target_regs_cons:
- forall s map a r al rl,
- reg_in_map map r \/ ~(In r rl) ->
- target_reg_ok s map a r ->
- target_regs_ok s map al rl ->
- target_regs_ok s map (Econs a al) (r :: rl).
-
-Lemma target_regs_ok_incr:
- forall s1 map al rl,
- target_regs_ok s1 map al rl ->
- forall s2,
- state_incr s1 s2 ->
- target_regs_ok s2 map al rl.
-Proof.
- induction 1; intros.
- apply target_regs_nil.
- apply target_regs_cons; eauto with rtlg.
-Qed.
-Hint Resolve target_regs_ok_incr: rtlg.
-
-Lemma target_regs_valid:
- forall s map al rl,
- target_regs_ok s map al rl ->
- map_wf map s ->
- forall r, In r rl -> reg_valid r s.
-Proof.
- induction 1; simpl; intros.
- contradiction.
- elim H3; intro.
- subst r0. eauto with rtlg.
- auto.
-Qed.
-Hint Resolve target_regs_valid: rtlg.
-
-Lemma alloc_regs_target_ok:
- forall al s1 s2 map rl,
- map_wf map s1 ->
- alloc_regs map al s1 = OK rl s2 ->
- target_regs_ok s2 map al rl.
-Proof.
- induction al; simpl; intros.
- monadInv H0. subst rl; apply target_regs_nil.
- monadInv H0. subst s0; subst rl.
- apply target_regs_cons; eauto 6 with rtlg.
- assert (MWF: map_wf map s). eauto with rtlg.
- elim (alloc_reg_fresh_or_in_map map e s r s2 MWF EQ0); intro.
- left; assumption. right; red; intro; eauto with rtlg.
-Qed.
-Hint Resolve alloc_regs_target_ok: rtlg.
-
-(** The following predicate is a variant of [target_reg_ok] used
- to characterize registers that are adequate for holding the return
- value of a function. *)
-
-Inductive return_reg_ok: state -> mapping -> option reg -> Prop :=
- | return_reg_ok_none:
- forall s map,
- return_reg_ok s map None
- | return_reg_ok_some:
- forall s map r,
- ~(reg_in_map map r) -> reg_valid r s ->
- return_reg_ok s map (Some r).
-
-Lemma return_reg_ok_incr:
- forall s1 s2 map or,
- state_incr s1 s2 ->
- return_reg_ok s1 map or ->
- return_reg_ok s2 map or.
-Proof.
- intros. inversion H0; constructor.
- assumption. eauto with rtlg.
-Qed.
-Hint Resolve return_reg_ok_incr: rtlg.
-
-Lemma new_reg_return_ok:
- forall s1 r s2 map sig,
- new_reg s1 = OK r s2 ->
- map_wf map s1 ->
- return_reg_ok s2 map (ret_reg sig r).
-Proof.
- intros. unfold ret_reg. destruct (sig_res sig); constructor.
- eauto with rtlg. eauto with rtlg.
-Qed.
-
-(** * Correspondence between Cminor environments and RTL register sets *)
-
-(** An RTL register environment matches a Cminor local environment and
- let-environment if the value of every local or let-bound variable in
- the Cminor environments is identical to the value of the
- corresponding pseudo-register in the RTL register environment. *)
-
-Record match_env
- (map: mapping) (e: Cminor.env) (le: Cminor.letenv) (rs: regset) : Prop :=
- mk_match_env {
- me_vars:
- (forall id v,
- e!id = Some v -> exists r, map.(map_vars)!id = Some r /\ rs#r = v);
- me_letvars:
- rs##(map.(map_letvars)) = le
- }.
-
-Lemma match_env_find_reg:
- forall map id s1 s2 r e le rs v,
- find_var map id s1 = OK r s2 ->
- match_env map e le rs ->
- e!id = Some v ->
- rs#r = v.
-Proof.
- intros until v.
- unfold find_var. caseEq (map.(map_vars)!id).
- intros r' EQ. monadSimpl. subst r'. intros.
- generalize (me_vars _ _ _ _ H _ _ H1). intros [r' [EQ' RS]].
- rewrite EQ' in EQ; injection EQ; intro; subst r'.
- assumption.
- intro; monadSimpl.
-Qed.
-Hint Resolve match_env_find_reg: rtlg.
-
-Lemma match_env_invariant:
- forall map e le rs rs',
- match_env map e le rs ->
- (forall r, (reg_in_map map r) -> rs'#r = rs#r) ->
- match_env map e le rs'.
-Proof.
- intros. apply mk_match_env.
- intros id v' E.
- generalize (me_vars _ _ _ _ H _ _ E). intros (r', (M, R)).
- exists r'. split. auto. rewrite <- R. apply H0.
- left. exists id. auto.
- transitivity rs ## (map_letvars map).
- apply list_map_exten. intros.
- symmetry. apply H0. right. auto.
- exact (me_letvars _ _ _ _ H).
-Qed.
-
-(** Matching between environments is preserved when an unmapped register
- (not corresponding to any Cminor variable) is assigned in the RTL
- execution. *)
-
-Lemma match_env_update_temp:
- forall map e le rs r v,
- match_env map e le rs ->
- ~(reg_in_map map r) ->
- match_env map e le (rs#r <- v).
-Proof.
- intros. apply match_env_invariant with rs; auto.
- intros. case (Reg.eq r r0); intro.
- subst r0; contradiction.
- apply Regmap.gso; auto.
-Qed.
-Hint Resolve match_env_update_temp: rtlg.
-
-(** Matching between environments is preserved by simultaneous
- assignment to a Cminor local variable (in the Cminor environments)
- and to the corresponding RTL pseudo-register (in the RTL register
- environment). *)
-
-Lemma match_env_update_var:
- forall map e le rs rs' id r v s s',
- map_wf map s ->
- find_var map id s = OK r s' ->
- match_env map e le rs ->
- rs'#r = v ->
- (forall x, x <> r -> rs'#x = rs#x) ->
- match_env map (PTree.set id v e) le rs'.
-Proof.
- intros until s'; intro MWF.
- unfold find_var in |- *. caseEq (map_vars map)!id.
- intros. monadInv H0. subst r0. apply mk_match_env.
- intros id' v' E. case (peq id' id); intros.
- subst id'. rewrite PTree.gss in E. injection E; intro; subst v'.
- exists r. split. auto. auto.
- rewrite PTree.gso in E; auto.
- elim (me_vars _ _ _ _ H1 _ _ E). intros r' (M, R).
- exists r'. split. assumption. rewrite <- R; apply H3; auto.
- red in |- *; intro. subst r'. apply n. eauto with rtlg.
- transitivity rs ## (map_letvars map).
- apply list_map_exten. intros. symmetry. apply H3.
- red in |- *; intro. subst x. eauto with rtlg.
- exact (me_letvars _ _ _ _ H1).
- intro; monadSimpl.
-Qed.
-
-Lemma match_env_letvar:
- forall map e le rs r v,
- match_env map e le rs ->
- rs#r = v ->
- match_env (add_letvar map r) e (v :: le) rs.
-Proof.
- intros. unfold add_letvar in |- *; apply mk_match_env; simpl in |- *.
- exact (me_vars _ _ _ _ H).
- rewrite H0. rewrite (me_letvars _ _ _ _ H). auto.
-Qed.
-
-Lemma match_env_exten:
- forall map e le rs1 rs2,
- (forall r, rs2#r = rs1#r) ->
- match_env map e le rs1 ->
- match_env map e le rs2.
-Proof.
- intros. apply mk_match_env.
- intros. generalize (me_vars _ _ _ _ H0 _ _ H1). intros (r, (M1, M2)).
- exists r. split. assumption. subst v. apply H.
- transitivity rs1 ## (map_letvars map).
- apply list_map_exten. intros. symmetry in |- *. apply H.
- exact (me_letvars _ _ _ _ H0).
-Qed.
-
-Lemma match_env_empty:
- forall map,
- map.(map_letvars) = nil ->
- match_env map (PTree.empty val) nil (Regmap.init Vundef).
-Proof.
- intros. apply mk_match_env.
- intros. rewrite PTree.gempty in H0. discriminate.
- rewrite H. reflexivity.
-Qed.
-
-(** The assignment of function arguments to local variables (on the Cminor
- side) and pseudo-registers (on the RTL side) preserves matching
- between environments. *)
-
-Lemma match_set_params_init_regs:
- forall il rl s1 map2 s2 vl,
- add_vars init_mapping il s1 = OK (rl, map2) s2 ->
- match_env map2 (set_params vl il) nil (init_regs vl rl)
- /\ (forall r, reg_fresh r s2 -> (init_regs vl rl)#r = Vundef).
-Proof.
- induction il; simpl in |- *; intros.
-
- monadInv H. intro; subst rl; simpl in |- *.
- split. apply match_env_empty. subst map2; auto.
- intros. apply Regmap.gi.
-
- monadInv H. intro EQ1; subst s0; subst y0; subst rl. clear H.
- monadInv EQ0. intro EQ2. subst x0; subst s0. simpl.
-
- assert (LV : map_letvars map2 = nil).
- transitivity (map_letvars y).
- eapply add_var_letenv; eauto.
- transitivity (map_letvars init_mapping).
- eapply add_vars_letenv; eauto.
- reflexivity.
-
- destruct vl.
- (* vl = nil *)
- generalize (IHil _ _ _ _ nil EQ). intros [ME UNDEF]. split.
- constructor. intros id v. subst map2. simpl.
- repeat rewrite PTree.gsspec; case (peq id a); intros.
- exists r; split. auto. rewrite Regmap.gi. congruence.
- destruct (me_vars _ _ _ _ ME id v H) as (r', (MV, IR)).
- exists r'. split. auto.
- replace (init_regs nil x) with (Regmap.init Vundef) in IR. auto.
- destruct x; reflexivity.
- rewrite LV; reflexivity.
- intros. apply Regmap.gi.
- (* vl = v :: vl *)
- generalize (IHil _ _ _ _ vl EQ). intros [ME UNDEF]. split.
- constructor. intros id v1. subst map2. simpl.
- repeat rewrite PTree.gsspec; case (peq id a); intros.
- exists r; split. auto. rewrite Regmap.gss. congruence.
- destruct (me_vars _ _ _ _ ME id v1 H) as (r', (MV, IR)).
- exists r'. split. auto. rewrite Regmap.gso. auto.
- apply valid_fresh_different with s.
- assert (MWF : map_wf y s).
- eapply add_vars_wf; eauto. apply init_mapping_wf.
- eauto with rtlg. eauto with rtlg.
- rewrite LV; reflexivity.
- intros. rewrite Regmap.gso. apply UNDEF. eauto with rtlg.
- apply sym_not_equal. eauto with rtlg.
-Qed.
-
-Lemma match_set_locals:
- forall map1 s1,
- map_wf map1 s1 ->
- forall il rl map2 s2 e le rs,
- match_env map1 e le rs ->
- (forall r, reg_fresh r s1 -> rs#r = Vundef) ->
- add_vars map1 il s1 = OK (rl, map2) s2 ->
- match_env map2 (set_locals il e) le rs.
-Proof.
- induction il; simpl in *; intros.
-
- monadInv H2. intros; subst map2; auto.
-
- monadInv H2. intros. subst s0; subst y0.
- assert (match_env y (set_locals il e) le rs).
- eapply IHil; eauto.
- monadInv EQ0. intro. subst s0; subst x0. rewrite <- H7.
- constructor.
- intros id v. simpl. repeat rewrite PTree.gsspec.
- case (peq id a); intros.
- exists r. split. auto. injection H5; intro; subst v.
- apply H1. apply reg_fresh_decr with s.
- eapply add_vars_incr; eauto.
- eauto with rtlg.
- eapply me_vars; eauto.
- simpl. eapply me_letvars; eauto.
-Qed.
-
-Lemma match_init_env_init_reg:
- forall params s0 rparams map1 s1 vars rvars map2 s2 vparams,
- add_vars init_mapping params s0 = OK (rparams, map1) s1 ->
- add_vars map1 vars s1 = OK (rvars, map2) s2 ->
- match_env map2 (set_locals vars (set_params vparams params))
- nil (init_regs vparams rparams).
-Proof.
- intros.
- generalize (match_set_params_init_regs _ _ _ _ _ vparams H).
- intros [A B].
- eapply match_set_locals; eauto.
- eapply add_vars_wf; eauto. apply init_mapping_wf.
-Qed.
-
-(** * Monotonicity properties of the state for the translation functions *)
-
-(** We show that the translation functions modify the state monotonically
- (in the sense of the [state_incr] relation). *)
-
-Lemma add_move_incr:
- forall r1 r2 nd s ns s',
- add_move r1 r2 nd s = OK ns s' ->
- state_incr s s'.
-Proof.
- intros until s'. unfold add_move.
- case (Reg.eq r1 r2); intro.
- monadSimpl. subst s'; auto with rtlg.
- intro; eauto with rtlg.
-Qed.
-Hint Resolve add_move_incr: rtlg.
-
-Scheme expr_ind3 := Induction for expr Sort Prop
- with condexpr_ind3 := Induction for condexpr Sort Prop
- with exprlist_ind3 := Induction for exprlist Sort Prop.
-
-Lemma expr_condexpr_exprlist_ind:
-forall (P : expr -> Prop) (P0 : condexpr -> Prop)
- (P1 : exprlist -> Prop),
- (forall i : ident, P (Evar i)) ->
- (forall (o : operation) (e : exprlist), P1 e -> P (Eop o e)) ->
- (forall (m : memory_chunk) (a : addressing) (e : exprlist),
- P1 e -> P (Eload m a e)) ->
- (forall (m : memory_chunk) (a : addressing) (e : exprlist),
- P1 e -> forall e0 : expr, P e0 -> P (Estore m a e e0)) ->
- (forall (s : signature) (e : expr),
- P e -> forall e0 : exprlist, P1 e0 -> P (Ecall s e e0)) ->
- (forall c : condexpr,
- P0 c ->
- forall e : expr,
- P e -> forall e0 : expr, P e0 -> P (Econdition c e e0)) ->
- (forall e : expr, P e -> forall e0 : expr, P e0 -> P (Elet e e0)) ->
- (forall n : nat, P (Eletvar n)) ->
- (forall e : expr, P e -> P (Ealloc e)) ->
- P0 CEtrue ->
- P0 CEfalse ->
- (forall (c : condition) (e : exprlist), P1 e -> P0 (CEcond c e)) ->
- (forall c : condexpr,
- P0 c ->
- forall c0 : condexpr,
- P0 c0 -> forall c1 : condexpr, P0 c1 -> P0 (CEcondition c c0 c1)) ->
- P1 Enil ->
- (forall e : expr,
- P e -> forall e0 : exprlist, P1 e0 -> P1 (Econs e e0)) ->
- (forall e : expr, P e) /\
- (forall ce : condexpr, P0 ce) /\
- (forall el : exprlist, P1 el).
-Proof.
- intros. split. apply (expr_ind3 P P0 P1); assumption.
- split. apply (condexpr_ind3 P P0 P1); assumption.
- apply (exprlist_ind3 P P0 P1); assumption.
-Qed.
-
-Definition transl_expr_incr_pred (a: expr) : Prop :=
- forall map rd nd s ns s',
- transl_expr map a rd nd s = OK ns s' -> state_incr s s'.
-Definition transl_condition_incr_pred (c: condexpr) : Prop :=
- forall map ntrue nfalse s ns s',
- transl_condition map c ntrue nfalse s = OK ns s' -> state_incr s s'.
-Definition transl_exprlist_incr_pred (al: exprlist) : Prop :=
- forall map rl nd s ns s',
- transl_exprlist map al rl nd s = OK ns s' -> state_incr s s'.
-
-Lemma transl_expr_condition_exprlist_incr:
- (forall a, transl_expr_incr_pred a) /\
- (forall c, transl_condition_incr_pred c) /\
- (forall al, transl_exprlist_incr_pred al).
-Proof.
- apply expr_condexpr_exprlist_ind;
- unfold transl_expr_incr_pred,
- transl_condition_incr_pred,
- transl_exprlist_incr_pred;
- simpl; intros;
- try (monadInv H); try (monadInv H0);
- try (monadInv H1); try (monadInv H2);
- eauto 6 with rtlg.
-
- intro EQ2.
- apply state_incr_trans3 with s0 s1 s2; eauto with rtlg.
-
- intro EQ4.
- apply state_incr_trans4 with s1 s2 s3 s4; eauto with rtlg.
-
- subst s'; auto with rtlg.
- subst s'; auto with rtlg.
- destruct rl; monadInv H. subst s'; auto with rtlg.
- destruct rl; monadInv H1. eauto with rtlg.
-Qed.
-
-Lemma transl_expr_incr:
- forall a map rd nd s ns s',
- transl_expr map a rd nd s = OK ns s' -> state_incr s s'.
-Proof (proj1 transl_expr_condition_exprlist_incr).
-
-Lemma transl_condition_incr:
- forall a map ntrue nfalse s ns s',
- transl_condition map a ntrue nfalse s = OK ns s' -> state_incr s s'.
-Proof (proj1 (proj2 transl_expr_condition_exprlist_incr)).
-
-Lemma transl_exprlist_incr:
- forall al map rl nd s ns s',
- transl_exprlist map al rl nd s = OK ns s' -> state_incr s s'.
-Proof (proj2 (proj2 transl_expr_condition_exprlist_incr)).
-
-Hint Resolve transl_expr_incr transl_condition_incr transl_exprlist_incr: rtlg.
-
-Lemma transl_exit_incr:
- forall nexits n s ns s',
- transl_exit nexits n s = OK ns s' ->
- state_incr s s'.
-Proof.
- intros until s'. unfold transl_exit.
- destruct (nth_error nexits n); intros; simplify_eq H; intros; subst s'.
- auto with rtlg.
-Qed.
-
-Hint Resolve transl_exit_incr: rtlg.
-
-Lemma transl_switch_incr:
- forall r nexits default cases s n s',
- transl_switch r nexits cases default s = OK n s' ->
- state_incr s s'.
-Proof.
- induction cases; simpl; intros.
- eauto with rtlg.
- destruct a as [key1 exit1].
- monadInv H. intros EQ2.
- apply state_incr_trans with s0. eauto.
- eauto with rtlg.
-Qed.
-
-Hint Resolve transl_switch_incr: rtlg.
-
-Lemma transl_stmt_incr:
- forall a map nd nexits nret rret s ns s',
- transl_stmt map a nd nexits nret rret s = OK ns s' ->
- state_incr s s'.
-Proof.
- induction a; simpl; intros.
-
- monadInv H. subst s'. auto with rtlg.
-
- monadInv H. eauto with rtlg.
-
- monadInv H. intro. apply state_incr_trans3 with s0 s1 s2; eauto with rtlg.
-
- monadInv H. eauto with rtlg.
-
- generalize H. case (more_likely c a1 a2); monadSimpl; eauto 6 with rtlg.
-
- monadInv H. subst s'.
- apply update_instr_incr with s0 s1 (Inop n0) n u; eauto with rtlg.
-
- eauto.
-
- eauto with rtlg.
-
- monadInv H. eauto 6 with rtlg.
-
- generalize H. destruct o; destruct rret; try monadSimpl.
- eauto with rtlg.
- subst s'; auto with rtlg.
-Qed.
-
-Hint Resolve transl_stmt_incr: rtlg.
-
diff --git a/backend/RTLgenspec.v b/backend/RTLgenspec.v
new file mode 100644
index 0000000000000000000000000000000000000000..c46bdbbaf10771bfea9b84f9dec53df46833b83d
--- /dev/null
+++ b/backend/RTLgenspec.v
@@ -0,0 +1,1455 @@
+(** Abstract specification of RTL generation *)
+
+(** In this module, we define inductive predicates that specify the
+ translations from Cminor to RTL performed by the functions in module
+ [RTLgen]. We then show that these functions satisfy these relational
+ specifications. The relational specifications will then be used
+ instead of the actual functions to show semantic equivalence between
+ the source Cminor code and the the generated RTL code
+ (see module [RTLgenproof]). *)
+
+Require Import Coqlib.
+Require Errors.
+Require Import Maps.
+Require Import AST.
+Require Import Integers.
+Require Import Values.
+Require Import Events.
+Require Import Mem.
+Require Import Globalenvs.
+Require Import Switch.
+Require Import Op.
+Require Import Registers.
+Require Import CminorSel.
+Require Import RTL.
+Require Import RTLgen.
+
+(** * Reasoning about monadic computations *)
+
+(** The tactics below simplify hypotheses of the form [f ... = OK x s]
+ where [f] is a monadic computation. For instance, the hypothesis
+ [(do x <- a; b) s = OK y s'] will generate the additional witnesses
+ [x], [s1] and the additional hypotheses
+ [a s = OK x s1] and [b x s1 = OK y s'], reflecting the fact that
+ both monadic computations [a] and [b] succeeded.
+*)
+
+Remark bind_inversion:
+ forall (A B: Set) (f: mon A) (g: A -> mon B) (y: B) (s1 s3: state),
+ bind f g s1 = OK y s3 ->
+ exists x, exists s2, f s1 = OK x s2 /\ g x s2 = OK y s3.
+Proof.
+ intros until s3. unfold bind. destruct (f s1); intros.
+ discriminate.
+ exists a; exists s; auto.
+Qed.
+
+Remark bind2_inversion:
+ forall (A B C: Set) (f: mon (A*B)) (g: A -> B -> mon C)
+ (z: C) (s1 s3: state),
+ bind2 f g s1 = OK z s3 ->
+ exists x, exists y, exists s2, f s1 = OK (x, y) s2 /\ g x y s2 = OK z s3.
+Proof.
+ intros until s3. unfold bind2, bind. destruct (f s1). congruence.
+ destruct p as [x y]; simpl; intro.
+ exists x; exists y; exists s; auto.
+Qed.
+
+Ltac monadInv1 H :=
+ match type of H with
+ | (OK _ _ = OK _ _) =>
+ inversion H; clear H; try subst
+ | (Error _ _ = OK _ _) =>
+ discriminate
+ | (ret _ _ = OK _ _) =>
+ inversion H; clear H; try subst
+ | (error _ _ = OK _ _) =>
+ discriminate
+ | (bind ?F ?G ?S = OK ?X ?S') =>
+ let x := fresh "x" in (
+ let s := fresh "s" in (
+ let EQ1 := fresh "EQ" in (
+ let EQ2 := fresh "EQ" in (
+ destruct (bind_inversion _ _ F G X S S' H) as [x [s [EQ1 EQ2]]];
+ clear H;
+ try (monadInv1 EQ2)))))
+ | (bind2 ?F ?G ?S = OK ?X ?S') =>
+ let x1 := fresh "x" in (
+ let x2 := fresh "x" in (
+ let s := fresh "s" in (
+ let EQ1 := fresh "EQ" in (
+ let EQ2 := fresh "EQ" in (
+ destruct (bind2_inversion _ _ _ F G X S S' H) as [x1 [x2 [s [EQ1 EQ2]]]];
+ clear H;
+ try (monadInv1 EQ2))))))
+ end.
+
+Ltac monadInv H :=
+ match type of H with
+ | (ret _ _ = OK _ _) => monadInv1 H
+ | (error _ _ = OK _ _) => monadInv1 H
+ | (bind ?F ?G ?S = OK ?X ?S') => monadInv1 H
+ | (bind2 ?F ?G ?S = OK ?X ?S') => monadInv1 H
+ | (?F _ _ _ _ _ _ _ _ = OK _ _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ _ _ _ _ = OK _ _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ _ _ _ = OK _ _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ _ _ = OK _ _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ _ = OK _ _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ = OK _ _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ = OK _ _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ = OK _ _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ end.
+
+(** * Monotonicity properties of the state *)
+
+(** Operations over the global state satisfy a crucial monotonicity property:
+ nodes are only added to the CFG, but never removed nor their instructions
+ changed; similarly, fresh nodes and fresh registers are only consumed,
+ but never reused. This property is captured by the following predicate
+ over states, which we show is a partial order. *)
+
+Inductive state_incr: state -> state -> Prop :=
+ state_incr_intro:
+ forall (s1 s2: state),
+ Ple s1.(st_nextnode) s2.(st_nextnode) ->
+ Ple s1.(st_nextreg) s2.(st_nextreg) ->
+ (forall pc, Plt pc s1.(st_nextnode) -> s2.(st_code)!pc = s1.(st_code)!pc) ->
+ state_incr s1 s2.
+
+Lemma instr_at_incr:
+ forall s1 s2 n i,
+ state_incr s1 s2 -> s1.(st_code)!n = Some i -> s2.(st_code)!n = Some i.
+Proof.
+ intros. inversion H.
+ rewrite H3. auto. elim (st_wf s1 n); intro.
+ assumption. congruence.
+Qed.
+
+Lemma state_incr_refl:
+ forall s, state_incr s s.
+Proof.
+ intros. apply state_incr_intro.
+ apply Ple_refl. apply Ple_refl. intros; auto.
+Qed.
+Hint Resolve state_incr_refl: rtlg.
+
+Lemma state_incr_trans:
+ forall s1 s2 s3, state_incr s1 s2 -> state_incr s2 s3 -> state_incr s1 s3.
+Proof.
+ intros. inversion H. inversion H0. apply state_incr_intro.
+ apply Ple_trans with (st_nextnode s2); assumption.
+ apply Ple_trans with (st_nextreg s2); assumption.
+ intros. transitivity (s2.(st_code)!pc).
+ apply H8. apply Plt_Ple_trans with s1.(st_nextnode); auto.
+ apply H3; auto.
+Qed.
+Hint Resolve state_incr_trans: rtlg.
+
+(** The following relation between two states is a weaker version of
+ [state_incr]. It permits changing the contents at an already reserved
+ graph node, but only from [None] to [Some i]. *)
+
+Definition state_extends (s1 s2: state): Prop :=
+ forall pc,
+ s1.(st_code)!pc = None \/ s2.(st_code)!pc = s1.(st_code)!pc.
+
+Lemma instr_at_extends:
+ forall s1 s2 pc i,
+ state_extends s1 s2 ->
+ s1.(st_code)!pc = Some i -> s2.(st_code)!pc = Some i.
+Proof.
+ intros. elim (H pc); intro. congruence. congruence.
+Qed.
+
+Lemma state_incr_extends:
+ forall s1 s2,
+ state_incr s1 s2 -> state_extends s1 s2.
+Proof.
+ unfold state_extends; intros. inversion H.
+ case (plt pc s1.(st_nextnode)); intro.
+ right; apply H2; auto.
+ left. elim (s1.(st_wf) pc); intro.
+ elim (n H5). auto.
+Qed.
+Hint Resolve state_incr_extends.
+
+(** * Validity and freshness of registers *)
+
+(** An RTL pseudo-register is valid in a given state if it was created
+ earlier, that is, it is less than the next fresh register of the state.
+ Otherwise, the pseudo-register is said to be fresh. *)
+
+Definition reg_valid (r: reg) (s: state) : Prop :=
+ Plt r s.(st_nextreg).
+
+Definition reg_fresh (r: reg) (s: state) : Prop :=
+ ~(Plt r s.(st_nextreg)).
+
+Lemma valid_fresh_absurd:
+ forall r s, reg_valid r s -> reg_fresh r s -> False.
+Proof.
+ intros r s. unfold reg_valid, reg_fresh; case r; tauto.
+Qed.
+Hint Resolve valid_fresh_absurd: rtlg.
+
+Lemma valid_fresh_different:
+ forall r1 r2 s, reg_valid r1 s -> reg_fresh r2 s -> r1 <> r2.
+Proof.
+ unfold not; intros. subst r2. eauto with rtlg.
+Qed.
+Hint Resolve valid_fresh_different: rtlg.
+
+Lemma reg_valid_incr:
+ forall r s1 s2, state_incr s1 s2 -> reg_valid r s1 -> reg_valid r s2.
+Proof.
+ intros r s1 s2 INCR.
+ inversion INCR.
+ unfold reg_valid. intros; apply Plt_Ple_trans with (st_nextreg s1); auto.
+Qed.
+Hint Resolve reg_valid_incr: rtlg.
+
+Lemma reg_fresh_decr:
+ forall r s1 s2, state_incr s1 s2 -> reg_fresh r s2 -> reg_fresh r s1.
+Proof.
+ intros r s1 s2 INCR. inversion INCR.
+ unfold reg_fresh; unfold not; intros.
+ apply H4. apply Plt_Ple_trans with (st_nextreg s1); auto.
+Qed.
+Hint Resolve reg_fresh_decr: rtlg.
+
+(** Validity of a list of registers. *)
+
+Definition regs_valid (rl: list reg) (s: state) : Prop :=
+ forall r, In r rl -> reg_valid r s.
+
+Lemma regs_valid_nil:
+ forall s, regs_valid nil s.
+Proof.
+ intros; red; intros. elim H.
+Qed.
+Hint Resolve regs_valid_nil: rtlg.
+
+Lemma regs_valid_cons:
+ forall r1 rl s,
+ reg_valid r1 s -> regs_valid rl s -> regs_valid (r1 :: rl) s.
+Proof.
+ intros; red; intros. elim H1; intro. subst r1; auto. auto.
+Qed.
+
+Lemma regs_valid_incr:
+ forall s1 s2 rl, state_incr s1 s2 -> regs_valid rl s1 -> regs_valid rl s2.
+Proof.
+ unfold regs_valid; intros; eauto with rtlg.
+Qed.
+Hint Resolve regs_valid_incr: rtlg.
+
+(** A register is ``in'' a mapping if it is associated with a Cminor
+ local or let-bound variable. *)
+
+Definition reg_in_map (m: mapping) (r: reg) : Prop :=
+ (exists id, m.(map_vars)!id = Some r) \/ In r m.(map_letvars).
+
+(** A compilation environment (mapping) is valid in a given state if
+ the registers associated with Cminor local variables and let-bound variables
+ are valid in the state. *)
+
+Definition map_valid (m: mapping) (s: state) : Prop :=
+ forall r, reg_in_map m r -> reg_valid r s.
+
+Lemma map_valid_incr:
+ forall s1 s2 m,
+ state_incr s1 s2 -> map_valid m s1 -> map_valid m s2.
+Proof.
+ unfold map_valid; intros; eauto with rtlg.
+Qed.
+Hint Resolve map_valid_incr: rtlg.
+
+(** * Properties of basic operations over the state *)
+
+(** Properties of [add_instr]. *)
+
+Lemma add_instr_incr:
+ forall s1 s2 i n,
+ add_instr i s1 = OK n s2 -> state_incr s1 s2.
+Proof.
+ intros. monadInv H.
+ apply state_incr_intro; simpl.
+ apply Ple_succ.
+ apply Ple_refl.
+ intros. apply PTree.gso; apply Plt_ne; auto.
+Qed.
+Hint Resolve add_instr_incr: rtlg.
+
+Lemma add_instr_at:
+ forall s1 s2 i n,
+ add_instr i s1 = OK n s2 -> s2.(st_code)!n = Some i.
+Proof.
+ intros. monadInv H. simpl. apply PTree.gss.
+Qed.
+Hint Resolve add_instr_at.
+
+(** Properties of [reserve_instr] and [update_instr]. *)
+
+Lemma reserve_instr_incr:
+ forall s1 s2 n,
+ reserve_instr s1 = OK n s2 -> state_incr s1 s2.
+Proof.
+ intros. monadInv H.
+ apply state_incr_intro; simpl.
+ apply Ple_succ.
+ apply Ple_refl.
+ auto.
+Qed.
+
+Lemma update_instr_incr:
+ forall s1 s2 s3 s4 i n t,
+ reserve_instr s1 = OK n s2 ->
+ state_incr s2 s3 ->
+ update_instr n i s3 = OK t s4 ->
+ state_incr s1 s4.
+Proof.
+ intros.
+ generalize H1; clear H1; unfold update_instr.
+ case (plt n (st_nextnode s3)); intros. 2: discriminate.
+ inv H1. inv H0. monadInv H; simpl in *.
+ apply state_incr_intro; simpl.
+ eapply Ple_trans; eauto. apply Plt_Ple. apply Plt_succ.
+ auto.
+ intros. rewrite PTree.gso.
+ apply H3. apply Plt_trans_succ; auto.
+ apply Plt_ne. auto.
+Qed.
+
+Lemma update_instr_extends:
+ forall s1 s2 s3 s4 i n t,
+ reserve_instr s1 = OK n s2 ->
+ state_incr s2 s3 ->
+ update_instr n i s3 = OK t s4 ->
+ state_extends s3 s4.
+Proof.
+ intros. injection H. intros EQ1 EQ2.
+ red; intros.
+ case (peq pc n); intro.
+ subst pc. left. inversion H0. rewrite H4. rewrite <- EQ1; simpl.
+ destruct (s1.(st_wf) n). rewrite <- EQ2 in H7. elim (Plt_strict _ H7).
+ auto.
+ rewrite <- EQ1; rewrite <- EQ2; simpl. apply Plt_succ.
+ generalize H1; unfold update_instr.
+ case (plt n s3.(st_nextnode)); intros; inv H2.
+ right; simpl. apply PTree.gso; auto.
+Qed.
+
+(** Properties of [new_reg]. *)
+
+Lemma new_reg_incr:
+ forall s1 s2 r, new_reg s1 = OK r s2 -> state_incr s1 s2.
+Proof.
+ intros. monadInv H.
+ apply state_incr_intro; simpl.
+ apply Ple_refl. apply Ple_succ. auto.
+Qed.
+Hint Resolve new_reg_incr: rtlg.
+
+Lemma new_reg_valid:
+ forall s1 s2 r,
+ new_reg s1 = OK r s2 -> reg_valid r s2.
+Proof.
+ intros. monadInv H.
+ unfold reg_valid; simpl. apply Plt_succ.
+Qed.
+Hint Resolve new_reg_valid: rtlg.
+
+Lemma new_reg_fresh:
+ forall s1 s2 r,
+ new_reg s1 = OK r s2 -> reg_fresh r s1.
+Proof.
+ intros. monadInv H.
+ unfold reg_fresh; simpl.
+ exact (Plt_strict _).
+Qed.
+Hint Resolve new_reg_fresh: rtlg.
+
+Lemma new_reg_not_in_map:
+ forall s1 s2 m r,
+ new_reg s1 = OK r s2 -> map_valid m s1 -> ~(reg_in_map m r).
+Proof.
+ unfold not; intros; eauto with rtlg.
+Qed.
+Hint Resolve new_reg_not_in_map: rtlg.
+
+(** * Properties of operations over compilation environments *)
+
+Lemma init_mapping_valid:
+ forall s, map_valid init_mapping s.
+Proof.
+ unfold map_valid, init_mapping.
+ intros s r [[id A] | B].
+ simpl in A. rewrite PTree.gempty in A; discriminate.
+ simpl in B. tauto.
+Qed.
+
+(** Properties of [find_var]. *)
+
+Lemma find_var_incr:
+ forall s1 s2 map name r,
+ find_var map name s1 = OK r s2 -> state_incr s1 s2.
+Proof.
+ intros until r. unfold find_var.
+ case (map_vars map)!name; intros; monadInv H.
+ auto with rtlg.
+Qed.
+Hint Resolve find_var_incr: rtlg.
+
+Lemma find_var_in_map:
+ forall s1 s2 map name r,
+ find_var map name s1 = OK r s2 -> reg_in_map map r.
+Proof.
+ intros until r. unfold find_var; caseEq (map.(map_vars)!name).
+ intros. inv H0. left; exists name; auto.
+ intros. inv H0.
+Qed.
+Hint Resolve find_var_in_map: rtlg.
+
+Lemma find_var_valid:
+ forall s1 s2 map name r,
+ find_var map name s1 = OK r s2 -> map_valid map s1 -> reg_valid r s1.
+Proof.
+ eauto with rtlg.
+Qed.
+Hint Resolve find_var_valid: rtlg.
+
+(** Properties of [find_letvar]. *)
+
+Lemma find_letvar_incr:
+ forall s1 s2 map idx r,
+ find_letvar map idx s1 = OK r s2 -> state_incr s1 s2.
+Proof.
+ intros until r. unfold find_letvar.
+ case (nth_error (map_letvars map) idx); intros; monadInv H.
+ auto with rtlg.
+Qed.
+Hint Resolve find_letvar_incr: rtlg.
+
+Lemma find_letvar_in_map:
+ forall s1 s2 map idx r,
+ find_letvar map idx s1 = OK r s2 -> reg_in_map map r.
+Proof.
+ intros until r. unfold find_letvar.
+ caseEq (nth_error (map_letvars map) idx); intros; monadInv H0.
+ right; apply nth_error_in with idx; auto.
+Qed.
+Hint Resolve find_letvar_in_map: rtlg.
+
+Lemma find_letvar_valid:
+ forall s1 s2 map idx r,
+ find_letvar map idx s1 = OK r s2 -> map_valid map s1 -> reg_valid r s1.
+Proof.
+ eauto with rtlg.
+Qed.
+Hint Resolve find_letvar_valid: rtlg.
+
+(** Properties of [add_var]. *)
+
+Lemma add_var_valid:
+ forall s1 s2 map1 map2 name r,
+ add_var map1 name s1 = OK (r, map2) s2 ->
+ map_valid map1 s1 ->
+ reg_valid r s2 /\ map_valid map2 s2.
+Proof.
+ intros. monadInv H.
+ split. eauto with rtlg.
+ inversion EQ. subst. red. intros r' [[id A] | B].
+ simpl in A. rewrite PTree.gsspec in A. destruct (peq id name).
+ inv A. eauto with rtlg.
+ apply reg_valid_incr with s1. eauto with rtlg.
+ apply H0. left; exists id; auto.
+ simpl in B. apply reg_valid_incr with s1. eauto with rtlg.
+ apply H0. right; auto.
+Qed.
+
+Lemma add_var_incr:
+ forall s1 s2 map name rm,
+ add_var map name s1 = OK rm s2 -> state_incr s1 s2.
+Proof.
+ intros. monadInv H. eauto with rtlg.
+Qed.
+Hint Resolve add_var_incr: rtlg.
+
+Lemma add_var_find:
+ forall s1 s2 map name r map',
+ add_var map name s1 = OK (r,map') s2 -> map'.(map_vars)!name = Some r.
+Proof.
+ intros. monadInv H. simpl. apply PTree.gss.
+Qed.
+
+Lemma add_vars_incr:
+ forall names s1 s2 map r,
+ add_vars map names s1 = OK r s2 -> state_incr s1 s2.
+Proof.
+ induction names; simpl; intros; monadInv H.
+ auto with rtlg.
+ eauto with rtlg.
+Qed.
+
+Lemma add_vars_valid:
+ forall namel s1 s2 map1 map2 rl,
+ add_vars map1 namel s1 = OK (rl, map2) s2 ->
+ map_valid map1 s1 ->
+ regs_valid rl s2 /\ map_valid map2 s2.
+Proof.
+ induction namel; simpl; intros; monadInv H.
+ split. red; simpl; intros; tauto. auto.
+ exploit IHnamel; eauto. intros [A B].
+ exploit add_var_valid; eauto. intros [C D].
+ exploit add_var_incr; eauto. intros INCR.
+ split. apply regs_valid_cons; eauto with rtlg.
+ auto.
+Qed.
+
+Lemma add_var_letenv:
+ forall map1 i s1 r map2 s2,
+ add_var map1 i s1 = OK (r, map2) s2 ->
+ map2.(map_letvars) = map1.(map_letvars).
+Proof.
+ intros; monadInv H. reflexivity.
+Qed.
+
+Lemma add_vars_letenv:
+ forall il map1 s1 rl map2 s2,
+ add_vars map1 il s1 = OK (rl, map2) s2 ->
+ map2.(map_letvars) = map1.(map_letvars).
+Proof.
+ induction il; simpl; intros; monadInv H.
+ reflexivity.
+ transitivity (map_letvars x0).
+ eapply add_var_letenv; eauto.
+ eauto.
+Qed.
+
+(** Properties of [add_letvar]. *)
+
+Lemma add_letvar_valid:
+ forall map s r,
+ map_valid map s ->
+ reg_valid r s ->
+ map_valid (add_letvar map r) s.
+Proof.
+ intros; red; intros.
+ destruct H1 as [[id A]|B].
+ simpl in A. apply H. left; exists id; auto.
+ simpl in B. elim B; intro.
+ subst r0; auto. apply H. right; auto.
+Qed.
+
+(** * Properties of [alloc_reg] and [alloc_regs] *)
+
+Lemma alloc_reg_incr:
+ forall a s1 s2 map r,
+ alloc_reg map a s1 = OK r s2 -> state_incr s1 s2.
+Proof.
+ intros until r. unfold alloc_reg.
+ case a; eauto with rtlg.
+Qed.
+Hint Resolve alloc_reg_incr: rtlg.
+
+Lemma alloc_reg_valid:
+ forall a s1 s2 map r,
+ map_valid map s1 ->
+ alloc_reg map a s1 = OK r s2 -> reg_valid r s2.
+Proof.
+ intros until r. unfold alloc_reg.
+ case a; eauto with rtlg.
+Qed.
+Hint Resolve alloc_reg_valid: rtlg.
+
+Lemma alloc_reg_fresh_or_in_map:
+ forall map a s r s',
+ map_valid map s ->
+ alloc_reg map a s = OK r s' ->
+ reg_in_map map r \/ reg_fresh r s.
+Proof.
+ intros until s'. unfold alloc_reg.
+ destruct a; intros; try (right; eauto with rtlg; fail).
+ left; eauto with rtlg.
+ left; eauto with rtlg.
+Qed.
+
+Lemma alloc_regs_incr:
+ forall al s1 s2 map rl,
+ alloc_regs map al s1 = OK rl s2 -> state_incr s1 s2.
+Proof.
+ induction al; simpl; intros; monadInv H; eauto with rtlg.
+Qed.
+Hint Resolve alloc_regs_incr: rtlg.
+
+Lemma alloc_regs_valid:
+ forall al s1 s2 map rl,
+ map_valid map s1 ->
+ alloc_regs map al s1 = OK rl s2 ->
+ regs_valid rl s2.
+Proof.
+ induction al; simpl; intros; monadInv H0.
+ apply regs_valid_nil.
+ apply regs_valid_cons. eauto with rtlg. eauto with rtlg.
+Qed.
+Hint Resolve alloc_regs_valid: rtlg.
+
+Lemma alloc_regs_fresh_or_in_map:
+ forall map al s rl s',
+ map_valid map s ->
+ alloc_regs map al s = OK rl s' ->
+ forall r, In r rl -> reg_in_map map r \/ reg_fresh r s.
+Proof.
+ induction al; simpl; intros; monadInv H0.
+ elim H1.
+ elim H1; intro.
+ subst r.
+ eapply alloc_reg_fresh_or_in_map; eauto.
+ exploit IHal. apply map_valid_incr with s0; eauto with rtlg. eauto. eauto.
+ intros [A|B]. auto. right; eauto with rtlg.
+Qed.
+
+(** A register is an adequate target for holding the value of an
+ expression if
+- either the register is associated with a Cminor let-bound variable
+ or a Cminor local variable;
+- or the register is not associated with any Cminor variable
+ and does not belong to the preserved set [pr]. *)
+
+Inductive target_reg_ok (map: mapping) (pr: list reg): expr -> reg -> Prop :=
+ | target_reg_var:
+ forall id r,
+ map.(map_vars)!id = Some r ->
+ target_reg_ok map pr (Evar id) r
+ | target_reg_letvar:
+ forall idx r,
+ nth_error map.(map_letvars) idx = Some r ->
+ target_reg_ok map pr (Eletvar idx) r
+ | target_reg_other:
+ forall a r,
+ ~(reg_in_map map r) -> ~In r pr ->
+ target_reg_ok map pr a r.
+
+Inductive target_regs_ok (map: mapping) (pr: list reg): exprlist -> list reg -> Prop :=
+ | target_regs_nil:
+ target_regs_ok map pr Enil nil
+ | target_regs_cons: forall a1 al r1 rl,
+ target_reg_ok map pr a1 r1 ->
+ target_regs_ok map (r1 :: pr) al rl ->
+ target_regs_ok map pr (Econs a1 al) (r1 :: rl).
+
+Lemma target_reg_ok_append:
+ forall map pr a r,
+ target_reg_ok map pr a r ->
+ forall pr',
+ (forall r', In r' pr' -> reg_in_map map r' \/ r' <> r) ->
+ target_reg_ok map (pr' ++ pr) a r.
+Proof.
+ induction 1; intros.
+ constructor; auto.
+ constructor; auto.
+ constructor; auto. red; intros.
+ elim (in_app_or _ _ _ H2); intro.
+ generalize (H1 _ H3). tauto. tauto.
+Qed.
+
+Lemma target_reg_ok_cons:
+ forall map pr a r,
+ target_reg_ok map pr a r ->
+ forall r',
+ reg_in_map map r' \/ r' <> r ->
+ target_reg_ok map (r' :: pr) a r.
+Proof.
+ intros. change (r' :: pr) with ((r' :: nil) ++ pr).
+ apply target_reg_ok_append; auto.
+ intros r'' [A|B]. subst r''; auto. contradiction.
+Qed.
+
+Lemma new_reg_target_ok:
+ forall map pr s1 a r s2,
+ map_valid map s1 ->
+ regs_valid pr s1 ->
+ new_reg s1 = OK r s2 ->
+ target_reg_ok map pr a r.
+Proof.
+ intros. constructor.
+ red; intro. apply valid_fresh_absurd with r s1.
+ eauto with rtlg. eauto with rtlg.
+ red; intro. apply valid_fresh_absurd with r s1.
+ auto. eauto with rtlg.
+Qed.
+
+Lemma alloc_reg_target_ok:
+ forall map pr s1 a r s2,
+ map_valid map s1 ->
+ regs_valid pr s1 ->
+ alloc_reg map a s1 = OK r s2 ->
+ target_reg_ok map pr a r.
+Proof.
+ intros. unfold alloc_reg in H1. destruct a;
+ try (eapply new_reg_target_ok; eauto; fail).
+ (* Evar *)
+ generalize H1; unfold find_var. caseEq (map_vars map)!i; intros.
+ inv H3. constructor. auto. inv H3.
+ (* Elet *)
+ generalize H1; unfold find_letvar. caseEq (nth_error (map_letvars map) n); intros.
+ inv H3. constructor. auto. inv H3.
+Qed.
+
+Lemma alloc_regs_target_ok:
+ forall map al pr s1 rl s2,
+ map_valid map s1 ->
+ regs_valid pr s1 ->
+ alloc_regs map al s1 = OK rl s2 ->
+ target_regs_ok map pr al rl.
+Proof.
+ induction al; intros; monadInv H1.
+ constructor.
+ constructor.
+ eapply alloc_reg_target_ok; eauto.
+ apply IHal with s s2; eauto with rtlg.
+ apply regs_valid_cons; eauto with rtlg.
+Qed.
+
+Hint Resolve new_reg_target_ok alloc_reg_target_ok alloc_regs_target_ok: rtlg.
+
+(** The following predicate is a variant of [target_reg_ok] used
+ to characterize registers that are adequate for holding the return
+ value of a function. *)
+
+Inductive return_reg_ok: state -> mapping -> option reg -> Prop :=
+ | return_reg_ok_none:
+ forall s map,
+ return_reg_ok s map None
+ | return_reg_ok_some:
+ forall s map r,
+ ~(reg_in_map map r) -> reg_valid r s ->
+ return_reg_ok s map (Some r).
+
+Lemma return_reg_ok_incr:
+ forall s map rret, return_reg_ok s map rret ->
+ forall s', state_incr s s' -> return_reg_ok s' map rret.
+Proof.
+ induction 1; intros; econstructor; eauto with rtlg.
+Qed.
+Hint Resolve return_reg_ok_incr: rtlg.
+
+Lemma new_reg_return_ok:
+ forall s1 r s2 map sig,
+ new_reg s1 = OK r s2 ->
+ map_valid map s1 ->
+ return_reg_ok s2 map (ret_reg sig r).
+Proof.
+ intros. unfold ret_reg. destruct (sig_res sig); constructor.
+ eauto with rtlg. eauto with rtlg.
+Qed.
+
+(** * Relational specification of the translation *)
+
+(** We now define inductive predicates that characterize the fact that
+ the control-flow graph produced by compilation of a Cminor function
+ contains sub-graphs that correspond to the translation of each
+ Cminor expression or statement in the original code. *)
+
+(** [tr_move c ns rs nd rd] holds if the graph [c], between nodes [ns]
+ and [nd], contains instructions that move the value of register [rs]
+ to register [rd]. *)
+
+Inductive tr_move (c: code):
+ node -> reg -> node -> reg -> Prop :=
+ | tr_move_0: forall n r,
+ tr_move c n r n r
+ | tr_move_1: forall ns rs nd rd,
+ c!ns = Some (Iop Omove (rs :: nil) rd nd) ->
+ tr_move c ns rs nd rd.
+
+(** [tr_expr c map pr expr ns nd rd] holds if the graph [c],
+ between nodes [ns] and [nd], contains instructions that compute the
+ value of the Cminor expression [expr] and deposit this value in
+ register [rd]. [map] is a mapping from Cminor variables to the
+ corresponding RTL registers. [pr] is a list of RTL registers whose
+ values must be preserved during this computation. All registers
+ mentioned in [map] must also be preserved during this computation.
+ To ensure this, we demand that the result registers of the instructions
+ appearing on the path from [ns] to [nd] are neither in [pr] nor in [map].
+*)
+
+Inductive tr_expr (c: code):
+ mapping -> list reg -> expr -> node -> node -> reg -> Prop :=
+ | tr_Evar: forall map pr id ns nd r rd,
+ map.(map_vars)!id = Some r ->
+ (rd = r \/ ~reg_in_map map rd /\ ~In rd pr) ->
+ tr_move c ns r nd rd ->
+ tr_expr c map pr (Evar id) ns nd rd
+ | tr_Eop: forall map pr op al ns nd rd n1 rl,
+ tr_exprlist c map pr al ns n1 rl ->
+ c!n1 = Some (Iop op rl rd nd) ->
+ ~reg_in_map map rd -> ~In rd pr ->
+ tr_expr c map pr (Eop op al) ns nd rd
+ | tr_Eload: forall map pr chunk addr al ns nd rd n1 rl,
+ tr_exprlist c map pr al ns n1 rl ->
+ c!n1 = Some (Iload chunk addr rl rd nd) ->
+ ~reg_in_map map rd -> ~In rd pr ->
+ tr_expr c map pr (Eload chunk addr al) ns nd rd
+ | tr_Estore: forall map pr chunk addr al b ns nd rd n1 rl n2,
+ tr_exprlist c map pr al ns n1 rl ->
+ tr_expr c map (rl ++ pr) b n1 n2 rd ->
+ c!n2 = Some (Istore chunk addr rl rd nd) ->
+ tr_expr c map pr (Estore chunk addr al b) ns nd rd
+ | tr_Ecall: forall map pr sig b cl ns nd rd n1 rf n2 rargs,
+ tr_expr c map pr b ns n1 rf ->
+ tr_exprlist c map (rf :: pr) cl n1 n2 rargs ->
+ c!n2 = Some (Icall sig (inl _ rf) rargs rd nd) ->
+ ~reg_in_map map rd -> ~In rd pr ->
+ tr_expr c map pr (Ecall sig b cl) ns nd rd
+ | tr_Econdition: forall map pr b ifso ifnot ns nd rd ntrue nfalse,
+ tr_condition c map pr b ns ntrue nfalse ->
+ tr_expr c map pr ifso ntrue nd rd ->
+ tr_expr c map pr ifnot nfalse nd rd ->
+ tr_expr c map pr (Econdition b ifso ifnot) ns nd rd
+ | tr_Elet: forall map pr b1 b2 ns nd rd n1 r,
+ ~reg_in_map map r ->
+ tr_expr c map pr b1 ns n1 r ->
+ tr_expr c (add_letvar map r) pr b2 n1 nd rd ->
+ tr_expr c map pr (Elet b1 b2) ns nd rd
+ | tr_Eletvar: forall map pr n ns nd rd r,
+ List.nth_error map.(map_letvars) n = Some r ->
+ (rd = r \/ ~reg_in_map map rd /\ ~In rd pr) ->
+ tr_move c ns r nd rd ->
+ tr_expr c map pr (Eletvar n) ns nd rd
+ | tr_Ealloc: forall map pr a ns nd rd n1 r,
+ tr_expr c map pr a ns n1 r ->
+ c!n1 = Some (Ialloc r rd nd) ->
+ ~reg_in_map map rd -> ~In rd pr ->
+ tr_expr c map pr (Ealloc a) ns nd rd
+
+(** [tr_expr c map pr cond ns ntrue nfalse rd] holds if the graph [c],
+ starting at node [ns], contains instructions that compute the truth
+ value of the Cminor conditional expression [cond] and terminate
+ on node [ntrue] if the condition holds and on node [nfalse] otherwise. *)
+
+with tr_condition (c: code):
+ mapping -> list reg -> condexpr -> node -> node -> node -> Prop :=
+ | tr_CEtrue: forall map pr ntrue nfalse,
+ tr_condition c map pr CEtrue ntrue ntrue nfalse
+ | tr_CEfalse: forall map pr ntrue nfalse,
+ tr_condition c map pr CEfalse nfalse ntrue nfalse
+ | tr_CEcond: forall map pr cond bl ns ntrue nfalse n1 rl,
+ tr_exprlist c map pr bl ns n1 rl ->
+ c!n1 = Some (Icond cond rl ntrue nfalse) ->
+ tr_condition c map pr (CEcond cond bl) ns ntrue nfalse
+ | tr_CEcondition: forall map pr b ifso ifnot ns ntrue nfalse ntrue' nfalse',
+ tr_condition c map pr b ns ntrue' nfalse' ->
+ tr_condition c map pr ifso ntrue' ntrue nfalse ->
+ tr_condition c map pr ifnot nfalse' ntrue nfalse ->
+ tr_condition c map pr (CEcondition b ifso ifnot) ns ntrue nfalse
+
+(** [tr_exprlist c map pr exprs ns nd rds] holds if the graph [c],
+ between nodes [ns] and [nd], contains instructions that compute the values
+ of the list of Cminor expression [exprlist] and deposit these values
+ in registers [rds]. *)
+
+with tr_exprlist (c: code):
+ mapping -> list reg -> exprlist -> node -> node -> list reg -> Prop :=
+ | tr_Enil: forall map pr n,
+ tr_exprlist c map pr Enil n n nil
+ | tr_Econs: forall map pr a1 al ns nd r1 rl n1,
+ tr_expr c map pr a1 ns n1 r1 ->
+ tr_exprlist c map (r1 :: pr) al n1 nd rl ->
+ tr_exprlist c map pr (Econs a1 al) ns nd (r1 :: rl).
+
+(** Auxiliary for the compilation of [switch] statements. *)
+
+Inductive tr_switch
+ (c: code) (r: reg) (nexits: list node):
+ comptree -> node -> Prop :=
+ | tr_switch_action: forall act n,
+ nth_error nexits act = Some n ->
+ tr_switch c r nexits (CTaction act) n
+ | tr_switch_ifeq: forall key act t' n ncont nfound,
+ tr_switch c r nexits t' ncont ->
+ nth_error nexits act = Some nfound ->
+ c!n = Some(Icond (Ccompimm Ceq key) (r :: nil) nfound ncont) ->
+ tr_switch c r nexits (CTifeq key act t') n
+ | tr_switch_iflt: forall key t1 t2 n n1 n2,
+ tr_switch c r nexits t1 n1 ->
+ tr_switch c r nexits t2 n2 ->
+ c!n = Some(Icond (Ccompuimm Clt key) (r :: nil) n1 n2) ->
+ tr_switch c r nexits (CTiflt key t1 t2) n.
+
+(** [tr_stmt c map stmt ns ncont nexits nret rret] holds if the graph [c],
+ starting at node [ns], contains instructions that perform the Cminor
+ statement [stmt]. These instructions branch to node [ncont] if
+ the statement terminates normally, to the [n]-th node in [nexits]
+ if the statement terminates prematurely on a [exit n] statement,
+ and to [nret] if the statement terminates prematurely on a [return]
+ statement. Moreover, if the [return] statement has an argument,
+ its value is deposited in register [rret]. *)
+
+Inductive tr_stmt (c: code) (map: mapping):
+ stmt -> node -> node -> list node -> node -> option reg -> Prop :=
+ | tr_Sskip: forall ns nexits nret rret,
+ tr_stmt c map Sskip ns ns nexits nret rret
+ | tr_Sexpr: forall a ns nd nexits nret rret r,
+ tr_expr c map nil a ns nd r ->
+ tr_stmt c map (Sexpr a) ns nd nexits nret rret
+ | tr_Sassign: forall id a ns nd nexits nret rret rv rt n,
+ map.(map_vars)!id = Some rv ->
+ tr_move c n rt nd rv ->
+ tr_expr c map nil a ns n rt ->
+ tr_stmt c map (Sassign id a) ns nd nexits nret rret
+ | tr_Sseq: forall s1 s2 ns nd nexits nret rret n,
+ tr_stmt c map s2 n nd nexits nret rret ->
+ tr_stmt c map s1 ns n nexits nret rret ->
+ tr_stmt c map (Sseq s1 s2) ns nd nexits nret rret
+ | tr_Sifthenelse: forall a strue sfalse ns nd nexits nret rret ntrue nfalse,
+ tr_stmt c map strue ntrue nd nexits nret rret ->
+ tr_stmt c map sfalse nfalse nd nexits nret rret ->
+ tr_condition c map nil a ns ntrue nfalse ->
+ tr_stmt c map (Sifthenelse a strue sfalse) ns nd nexits nret rret
+ | tr_Sloop: forall sbody ns nd nexits nret rret nloop,
+ tr_stmt c map sbody ns nloop nexits nret rret ->
+ c!nloop = Some(Inop ns) ->
+ tr_stmt c map (Sloop sbody) ns nd nexits nret rret
+ | tr_Sblock: forall sbody ns nd nexits nret rret,
+ tr_stmt c map sbody ns nd (nd :: nexits) nret rret ->
+ tr_stmt c map (Sblock sbody) ns nd nexits nret rret
+ | tr_Sexit: forall n ns nd nexits nret rret,
+ nth_error nexits n = Some ns ->
+ tr_stmt c map (Sexit n) ns nd nexits nret rret
+ | tr_Sswitch: forall a cases default ns nd nexits nret rret n r t,
+ validate_switch default cases t = true ->
+ tr_expr c map nil a ns n r ->
+ tr_switch c r nexits t n ->
+ tr_stmt c map (Sswitch a cases default) ns nd nexits nret rret
+ | tr_Sreturn_none: forall nret nd nexits,
+ tr_stmt c map (Sreturn None) nret nd nexits nret None
+ | tr_Sreturn_some: forall a ns nd nexits nret rret,
+ tr_expr c map nil a ns nret rret ->
+ tr_stmt c map (Sreturn (Some a)) ns nd nexits nret (Some rret)
+ | tr_Stailcall: forall sig b cl ns nd nexits nret rret n1 rf n2 rargs,
+ tr_expr c map nil b ns n1 rf ->
+ tr_exprlist c map (rf :: nil) cl n1 n2 rargs ->
+ c!n2 = Some (Itailcall sig (inl _ rf) rargs) ->
+ tr_stmt c map (Stailcall sig b cl) ns nd nexits nret rret.
+
+(** [tr_function f tf] specifies the RTL function [tf] that
+ [RTLgen.transl_function] returns. *)
+
+Inductive tr_function: CminorSel.function -> RTL.function -> Prop :=
+ | tr_function_intro:
+ forall f code rparams map1 s1 rvars map2 s2 nentry nret rret orret nextnode wfcode,
+ add_vars init_mapping f.(CminorSel.fn_params) init_state = OK (rparams, map1) s1 ->
+ add_vars map1 f.(CminorSel.fn_vars) s1 = OK (rvars, map2) s2 ->
+ orret = ret_reg f.(CminorSel.fn_sig) rret ->
+ tr_stmt code map2 f.(CminorSel.fn_body) nentry nret nil nret orret ->
+ code!nret = Some(Ireturn orret) ->
+ tr_function f (RTL.mkfunction
+ f.(CminorSel.fn_sig)
+ rparams
+ f.(CminorSel.fn_stackspace)
+ code
+ nentry
+ nextnode
+ wfcode).
+
+(** * Correctness proof of the translation functions *)
+
+(** We now show that the translation functions in module [RTLgen]
+ satisfy the specifications given above as inductive predicates. *)
+
+Scheme tr_expr_ind3 := Minimality for tr_expr Sort Prop
+ with tr_condition_ind3 := Minimality for tr_condition Sort Prop
+ with tr_exprlist_ind3 := Minimality for tr_exprlist Sort Prop.
+
+Definition tr_expr_condition_exprlist_ind3
+ (c: code)
+ (P : mapping -> list reg -> expr -> node -> node -> reg -> Prop)
+ (P0 : mapping -> list reg -> condexpr -> node -> node -> node -> Prop)
+ (P1 : mapping -> list reg -> exprlist -> node -> node -> list reg -> Prop) :=
+ fun a b c' d e f g h i j k l m n o =>
+ conj (tr_expr_ind3 c P P0 P1 a b c' d e f g h i j k l m n o)
+ (conj (tr_condition_ind3 c P P0 P1 a b c' d e f g h i j k l m n o)
+ (tr_exprlist_ind3 c P P0 P1 a b c' d e f g h i j k l m n o)).
+
+Lemma tr_move_extends:
+ forall s1 s2, state_extends s1 s2 ->
+ forall ns rs nd rd,
+ tr_move s1.(st_code) ns rs nd rd ->
+ tr_move s2.(st_code) ns rs nd rd.
+Proof.
+ induction 2; econstructor; eauto.
+ eapply instr_at_extends; eauto.
+Qed.
+
+Lemma tr_expr_condition_exprlist_extends:
+ forall s1 s2, state_extends s1 s2 ->
+ (forall map pr a ns nd rd,
+ tr_expr s1.(st_code) map pr a ns nd rd ->
+ tr_expr s2.(st_code) map pr a ns nd rd)
+/\(forall map pr a ns ntrue nfalse,
+ tr_condition s1.(st_code) map pr a ns ntrue nfalse ->
+ tr_condition s2.(st_code) map pr a ns ntrue nfalse)
+/\(forall map pr al ns nd rl,
+ tr_exprlist s1.(st_code) map pr al ns nd rl ->
+ tr_exprlist s2.(st_code) map pr al ns nd rl).
+Proof.
+ intros s1 s2 EXT.
+ pose (AT := fun pc i => instr_at_extends s1 s2 pc i EXT).
+ apply tr_expr_condition_exprlist_ind3; intros; econstructor; eauto.
+ eapply tr_move_extends; eauto.
+ eapply tr_move_extends; eauto.
+Qed.
+
+Lemma tr_expr_incr:
+ forall s1 s2, state_incr s1 s2 ->
+ forall map pr a ns nd rd,
+ tr_expr s1.(st_code) map pr a ns nd rd ->
+ tr_expr s2.(st_code) map pr a ns nd rd.
+Proof.
+ intros.
+ exploit tr_expr_condition_exprlist_extends.
+ apply state_incr_extends; eauto. intros [A [B C]]. eauto.
+Qed.
+
+Lemma tr_condition_incr:
+ forall s1 s2, state_incr s1 s2 ->
+ forall map pr a ns ntrue nfalse,
+ tr_condition s1.(st_code) map pr a ns ntrue nfalse ->
+ tr_condition s2.(st_code) map pr a ns ntrue nfalse.
+Proof.
+ intros.
+ exploit tr_expr_condition_exprlist_extends.
+ apply state_incr_extends; eauto. intros [A [B C]]. eauto.
+Qed.
+
+Lemma tr_exprlist_incr:
+ forall s1 s2, state_incr s1 s2 ->
+ forall map pr al ns nd rl,
+ tr_exprlist s1.(st_code) map pr al ns nd rl ->
+ tr_exprlist s2.(st_code) map pr al ns nd rl.
+Proof.
+ intros.
+ exploit tr_expr_condition_exprlist_extends.
+ apply state_incr_extends; eauto. intros [A [B C]]. eauto.
+Qed.
+
+Scheme expr_ind3 := Induction for expr Sort Prop
+ with condexpr_ind3 := Induction for condexpr Sort Prop
+ with exprlist_ind3 := Induction for exprlist Sort Prop.
+
+Definition expr_condexpr_exprlist_ind
+ (P1: expr -> Prop) (P2: condexpr -> Prop) (P3: exprlist -> Prop) :=
+ fun a b c d e f g h i j k l m n o =>
+ conj (expr_ind3 P1 P2 P3 a b c d e f g h i j k l m n o)
+ (conj (condexpr_ind3 P1 P2 P3 a b c d e f g h i j k l m n o)
+ (exprlist_ind3 P1 P2 P3 a b c d e f g h i j k l m n o)).
+
+Lemma add_move_charact:
+ forall s ns rs nd rd s',
+ add_move rs rd nd s = OK ns s' ->
+ tr_move s'.(st_code) ns rs nd rd /\ state_incr s s'.
+Proof.
+ intros. unfold add_move in H. destruct (Reg.eq rs rd).
+ inv H. split. constructor. auto with rtlg.
+ split. constructor. eauto with rtlg. eauto with rtlg.
+Qed.
+
+Lemma transl_expr_condexpr_list_charact:
+ (forall a map rd nd s ns s' pr
+ (TR: transl_expr map a rd nd s = OK ns s')
+ (WF: map_valid map s)
+ (OK: target_reg_ok map pr a rd)
+ (VALID: regs_valid pr s)
+ (VALID2: reg_valid rd s),
+ tr_expr s'.(st_code) map pr a ns nd rd
+ /\ state_incr s s')
+/\
+ (forall a map ntrue nfalse s ns s' pr
+ (TR: transl_condition map a ntrue nfalse s = OK ns s')
+ (WF: map_valid map s)
+ (VALID: regs_valid pr s),
+ tr_condition s'.(st_code) map pr a ns ntrue nfalse
+ /\ state_incr s s')
+/\
+ (forall al map rl nd s ns s' pr
+ (TR: transl_exprlist map al rl nd s = OK ns s')
+ (WF: map_valid map s)
+ (OK: target_regs_ok map pr al rl)
+ (VALID1: regs_valid pr s)
+ (VALID2: regs_valid rl s),
+ tr_exprlist s'.(st_code) map pr al ns nd rl
+ /\ state_incr s s').
+Proof.
+ apply expr_condexpr_exprlist_ind; intros; try (monadInv TR).
+ (* Evar *)
+ generalize EQ; unfold find_var. caseEq (map_vars map)!i; intros; inv EQ1.
+ exploit add_move_charact; eauto.
+ intros [A B].
+ split. econstructor; eauto.
+ inv OK. left; congruence. right; eauto.
+ auto.
+ (* Eop *)
+ inv OK.
+ exploit (H _ _ _ _ _ _ pr EQ2); eauto with rtlg. intros [A B].
+ split. econstructor; eauto.
+ eapply instr_at_incr; eauto.
+ apply state_incr_trans with s1; eauto with rtlg.
+ (* Eload *)
+ inv OK.
+ exploit (H _ _ _ _ _ _ pr EQ2); eauto with rtlg. intros [A B].
+ split. econstructor; eauto.
+ eapply instr_at_incr; eauto.
+ apply state_incr_trans with s1; eauto with rtlg.
+ (* Estore *)
+ inv OK.
+ assert (state_incr s s1). eauto with rtlg.
+ exploit (H0 _ _ _ _ _ _ (x ++ pr) EQ0).
+ eauto with rtlg.
+ apply target_reg_ok_append. constructor; auto.
+ intros. exploit alloc_regs_fresh_or_in_map; eauto.
+ intros [A|B]. auto. right. apply sym_not_equal.
+ eapply valid_fresh_different; eauto with rtlg.
+ red; intros. elim (in_app_or _ _ _ H4); intro.
+ exploit alloc_regs_valid; eauto with rtlg.
+ generalize (VALID _ H5). eauto with rtlg.
+ eauto with rtlg.
+ intros [A B].
+ exploit (H _ _ _ _ _ _ pr EQ3); eauto with rtlg.
+ intros [C D].
+ split. econstructor; eauto.
+ apply tr_expr_incr with s2; eauto with rtlg.
+ apply instr_at_incr with s1; eauto with rtlg.
+ eauto with rtlg.
+ (* Ecall *)
+ inv OK.
+ assert (state_incr s0 s3).
+ apply state_incr_trans with s1. eauto with rtlg.
+ apply state_incr_trans with s2; eauto with rtlg.
+ assert (regs_valid (x :: pr) s1).
+ apply regs_valid_cons; eauto with rtlg.
+ exploit (H0 _ _ _ _ _ _ (x :: pr) EQ2).
+ eauto with rtlg.
+ apply alloc_regs_target_ok with s1 s2; eauto with rtlg.
+ eauto with rtlg.
+ apply regs_valid_incr with s2; eauto with rtlg.
+ intros [A B].
+ exploit (H _ _ _ _ _ _ pr EQ4).
+ eauto with rtlg.
+ eauto with rtlg.
+ apply regs_valid_incr with s0; eauto with rtlg.
+ apply reg_valid_incr with s1; eauto with rtlg.
+ intros [C D].
+ split. econstructor; eauto.
+ apply tr_exprlist_incr with s4; eauto.
+ apply instr_at_incr with s3; eauto with rtlg.
+ eauto with rtlg.
+ (* Econdition *)
+ inv OK.
+ exploit (H1 _ _ _ _ _ _ pr EQ); eauto with rtlg.
+ constructor; auto.
+ intros [A B].
+ exploit (H0 _ _ _ _ _ _ pr EQ1); eauto with rtlg.
+ constructor; auto.
+ intros [C D].
+ exploit (H _ _ _ _ _ _ pr EQ2); eauto with rtlg.
+ intros [E F].
+ split. econstructor; eauto.
+ apply tr_expr_incr with s1; auto.
+ apply tr_expr_incr with s0; eauto with rtlg.
+ apply state_incr_trans with s0; auto.
+ apply state_incr_trans with s1; auto.
+ (* Elet *)
+ inv OK.
+ exploit (H0 _ _ _ _ _ _ pr EQ1).
+ apply add_letvar_valid; eauto with rtlg.
+ constructor; auto.
+ red; unfold reg_in_map. simpl. intros [[id A] | [B | C]].
+ elim H1. left; exists id; auto.
+ subst x. apply valid_fresh_absurd with rd s. auto. eauto with rtlg.
+ elim H1. right; auto.
+ eauto with rtlg. eauto with rtlg.
+ intros [A B].
+ exploit (H _ _ _ _ _ _ pr EQ2); eauto with rtlg. intros [C D].
+ split. econstructor.
+ eapply new_reg_not_in_map; eauto with rtlg. eauto.
+ apply tr_expr_incr with s1; auto.
+ eauto with rtlg.
+ (* Eletvar *)
+ generalize EQ; unfold find_letvar. caseEq (nth_error (map_letvars map) n); intros; inv EQ0.
+ monadInv EQ1.
+ exploit add_move_charact; eauto.
+ intros [A B].
+ split. econstructor; eauto.
+ inv OK. left; congruence. right; eauto.
+ auto.
+ monadInv EQ1.
+ (* Ealloc *)
+ inv OK.
+ exploit (H _ _ _ _ _ _ pr EQ2); eauto with rtlg.
+ intros [A B].
+ split. econstructor; eauto.
+ eapply instr_at_incr; eauto.
+ apply state_incr_trans with s1; eauto with rtlg.
+
+ (* CEtrue *)
+ split. constructor. auto with rtlg.
+ (* CEfalse *)
+ split. constructor. auto with rtlg.
+ (* CEcond *)
+ exploit (H _ _ _ _ _ _ pr EQ2); eauto with rtlg.
+ intros [A B].
+ split. econstructor; eauto.
+ apply instr_at_incr with s1; eauto with rtlg.
+ eauto with rtlg.
+ (* CEcondition *)
+ exploit (H1 _ _ _ _ _ _ pr EQ); eauto with rtlg.
+ intros [A B].
+ exploit (H0 _ _ _ _ _ _ pr EQ1); eauto with rtlg.
+ intros [C D].
+ exploit (H _ _ _ _ _ _ pr EQ2); eauto with rtlg.
+ intros [E F].
+ split. econstructor; eauto.
+ apply tr_condition_incr with s1; eauto with rtlg.
+ apply tr_condition_incr with s0; eauto with rtlg.
+ eauto with rtlg.
+
+ (* Enil *)
+ destruct rl; inv TR. split. constructor. eauto with rtlg.
+ (* Econs *)
+ destruct rl; simpl in TR; monadInv TR. inv OK.
+ exploit H0; eauto.
+ apply regs_valid_cons. apply VALID2. auto with coqlib. auto.
+ red; intros; apply VALID2; auto with coqlib.
+ intros [A B].
+ exploit H; eauto.
+ eauto with rtlg.
+ eauto with rtlg.
+ generalize (VALID2 r (in_eq _ _)). eauto with rtlg.
+ intros [C D].
+ split. econstructor; eauto.
+ apply tr_exprlist_incr with s0; auto.
+ apply state_incr_trans with s0; eauto with rtlg.
+Qed.
+
+Lemma transl_expr_charact:
+ forall a map rd nd s ns s'
+ (TR: transl_expr map a rd nd s = OK ns s')
+ (WF: map_valid map s)
+ (OK: target_reg_ok map nil a rd)
+ (VALID2: reg_valid rd s),
+ tr_expr s'.(st_code) map nil a ns nd rd
+ /\ state_incr s s'.
+Proof.
+ destruct transl_expr_condexpr_list_charact as [A [B C]].
+ intros. eapply A; eauto with rtlg.
+Qed.
+
+Lemma transl_condexpr_charact:
+ forall a map ntrue nfalse s ns s'
+ (TR: transl_condition map a ntrue nfalse s = OK ns s')
+ (WF: map_valid map s),
+ tr_condition s'.(st_code) map nil a ns ntrue nfalse
+ /\ state_incr s s'.
+Proof.
+ destruct transl_expr_condexpr_list_charact as [A [B C]].
+ intros. eapply B; eauto with rtlg.
+Qed.
+
+Lemma tr_switch_extends:
+ forall s1 s2, state_extends s1 s2 ->
+ forall r nexits t ns,
+ tr_switch s1.(st_code) r nexits t ns ->
+ tr_switch s2.(st_code) r nexits t ns.
+Proof.
+ induction 2; econstructor; eauto with rtlg.
+ eapply instr_at_extends; eauto.
+ eapply instr_at_extends; eauto.
+Qed.
+
+Lemma tr_stmt_extends:
+ forall s1 s2, state_extends s1 s2 ->
+ forall map s ns nd nexits nret rret,
+ tr_stmt s1.(st_code) map s ns nd nexits nret rret ->
+ tr_stmt s2.(st_code) map s ns nd nexits nret rret.
+Proof.
+ intros s1 s2 EXT.
+ destruct (tr_expr_condition_exprlist_extends s1 s2 EXT) as [A [B C]].
+ pose (AT := fun pc i => instr_at_extends s1 s2 pc i EXT).
+ induction 1; econstructor; eauto.
+ eapply tr_move_extends; eauto.
+ eapply tr_switch_extends; eauto.
+Qed.
+
+Lemma tr_stmt_incr:
+ forall s1 s2, state_incr s1 s2 ->
+ forall map s ns nd nexits nret rret,
+ tr_stmt s1.(st_code) map s ns nd nexits nret rret ->
+ tr_stmt s2.(st_code) map s ns nd nexits nret rret.
+Proof.
+ intros. eapply tr_stmt_extends; eauto with rtlg.
+Qed.
+
+Lemma transl_exit_charact:
+ forall nexits n s ne s',
+ transl_exit nexits n s = OK ne s' ->
+ nth_error nexits n = Some ne /\ s' = s.
+Proof.
+ intros until s'. unfold transl_exit.
+ destruct (nth_error nexits n); intro; monadInv H. auto.
+Qed.
+
+Lemma transl_switch_charact:
+ forall r nexits t s ns s',
+ transl_switch r nexits t s = OK ns s' ->
+ tr_switch s'.(st_code) r nexits t ns /\ state_incr s s'.
+Proof.
+ induction t; simpl; intros.
+ exploit transl_exit_charact; eauto. intros [A B].
+ split. econstructor; eauto. subst s'; auto with rtlg.
+
+ monadInv H.
+ exploit transl_exit_charact; eauto. intros [A B]. subst s1.
+ exploit IHt; eauto. intros [C D].
+ split. econstructor; eauto with rtlg.
+ apply tr_switch_extends with s0; eauto with rtlg.
+ eauto with rtlg.
+
+ monadInv H.
+ exploit IHt2; eauto. intros [A B].
+ exploit IHt1; eauto. intros [C D].
+ split. econstructor.
+ apply tr_switch_extends with s1; eauto with rtlg.
+ apply tr_switch_extends with s0; eauto with rtlg.
+ eauto with rtlg.
+ eauto with rtlg.
+Qed.
+
+Lemma transl_stmt_charact:
+ forall map stmt nd nexits nret rret s ns s'
+ (TR: transl_stmt map stmt nd nexits nret rret s = OK ns s')
+ (WF: map_valid map s)
+ (OK: return_reg_ok s map rret),
+ tr_stmt s'.(st_code) map stmt ns nd nexits nret rret
+ /\ state_incr s s'.
+Proof.
+ induction stmt; intros; simpl in TR; try (monadInv TR).
+ (* Sskip *)
+ split. constructor. auto with rtlg.
+ (* Sexpr *)
+ exploit transl_expr_charact; eauto with rtlg. intros [A B].
+ split. econstructor; eauto. eauto with rtlg.
+ (* Sassign *)
+ exploit add_move_charact; eauto. intros [A B].
+ exploit transl_expr_charact; eauto with rtlg.
+ apply map_valid_incr with s; eauto with rtlg.
+ intros [C D].
+ generalize EQ. unfold find_var. caseEq (map_vars map)!i; intros; inv EQ2.
+ split. econstructor; eauto.
+ apply tr_move_extends with s2; eauto with rtlg.
+ eauto with rtlg.
+ (* Sseq *)
+ exploit IHstmt2; eauto with rtlg. intros [A B].
+ exploit IHstmt1; eauto with rtlg. intros [C D].
+ split. econstructor; eauto. apply tr_stmt_incr with s0; eauto with rtlg.
+ eauto with rtlg.
+ (* Sifthenelse *)
+ destruct (more_likely c stmt1 stmt2); monadInv TR.
+ exploit IHstmt2; eauto. intros [A B].
+ exploit IHstmt1; eauto with rtlg. intros [C D].
+ exploit transl_condexpr_charact; eauto with rtlg. intros [E F].
+ split. econstructor; eauto.
+ apply tr_stmt_incr with s1; eauto with rtlg.
+ apply tr_stmt_incr with s0; eauto with rtlg.
+ eauto with rtlg.
+ exploit IHstmt1; eauto. intros [A B].
+ exploit IHstmt2; eauto with rtlg. intros [C D].
+ exploit transl_condexpr_charact; eauto with rtlg. intros [E F].
+ split. econstructor; eauto.
+ apply tr_stmt_incr with s0; eauto with rtlg.
+ apply tr_stmt_incr with s1; eauto with rtlg.
+ eauto with rtlg.
+ (* Sloop *)
+ assert (state_incr s s0).
+ eapply reserve_instr_incr; eauto.
+ exploit IHstmt; eauto with rtlg. intros [A B].
+ split. econstructor.
+ apply tr_stmt_extends with s1; eauto.
+ eapply update_instr_extends; eauto.
+ unfold update_instr in EQ0.
+ destruct (plt x (st_nextnode s1)); inv EQ0.
+ simpl. apply PTree.gss.
+ eapply update_instr_incr; eauto.
+ (* Sblock *)
+ exploit IHstmt; eauto. intros [A B].
+ split. econstructor; eauto. auto.
+ (* Sexit *)
+ exploit transl_exit_charact; eauto. intros [A B]. subst s'.
+ split. econstructor; eauto. auto with rtlg.
+ (* Sswitch *)
+ generalize TR; clear TR.
+ set (t := compile_switch n l).
+ caseEq (validate_switch n l t); intro VALID; intros.
+ monadInv TR.
+ exploit transl_switch_charact; eauto with rtlg. intros [A B].
+ exploit transl_expr_charact; eauto with rtlg. intros [C D].
+ split. econstructor; eauto with rtlg.
+ apply tr_switch_extends with s1; eauto with rtlg.
+ eauto with rtlg.
+ monadInv TR.
+ (* Sreturn *)
+ destruct o; destruct rret; inv TR.
+ inv OK.
+ exploit transl_expr_charact; eauto with rtlg.
+ constructor. auto. simpl; tauto.
+ intros [A B].
+ split. econstructor; eauto. auto.
+ split. constructor. auto with rtlg.
+ (* Stailcall *)
+ assert (state_incr s0 s2) by eauto with rtlg.
+ destruct transl_expr_condexpr_list_charact as [A [B C]].
+ exploit (C _ _ _ _ _ _ _ (x ::nil) EQ2); eauto with rtlg.
+ apply alloc_regs_target_ok with s1 s2; eauto with rtlg.
+ apply regs_valid_cons. eauto with rtlg. apply regs_valid_nil.
+ apply regs_valid_cons. apply reg_valid_incr with s1; eauto with rtlg.
+ apply regs_valid_nil.
+ apply regs_valid_incr with s2; eauto with rtlg.
+ intros [D E].
+ exploit (A _ _ _ _ _ _ _ nil EQ4); eauto with rtlg.
+ apply reg_valid_incr with s1; eauto with rtlg.
+ intros [F G].
+ split. econstructor; eauto.
+ apply tr_exprlist_incr with s4; eauto.
+ apply instr_at_incr with s3; eauto with rtlg.
+ eauto with rtlg.
+Qed.
+
+Lemma transl_function_charact:
+ forall f tf,
+ transl_function f = Errors.OK tf ->
+ tr_function f tf.
+Proof.
+ intros until tf. unfold transl_function.
+ caseEq (transl_fun f init_state). congruence.
+ intros [nentry rparams] sfinal TR E. inv E.
+ monadInv TR.
+ exploit add_vars_valid. eexact EQ. apply init_mapping_valid.
+ intros [A B].
+ exploit add_vars_valid. eexact EQ1. auto.
+ intros [C D].
+ exploit transl_stmt_charact; eauto with rtlg.
+ unfold ret_reg. destruct (sig_res (CminorSel.fn_sig f)).
+ constructor. eauto with rtlg. eauto with rtlg.
+ constructor.
+ intros [E F].
+ eapply tr_function_intro; eauto with rtlg.
+ apply instr_at_incr with s2; eauto with rtlg.
+Qed.
diff --git a/backend/RTLtyping.v b/backend/RTLtyping.v
index 97d063ace67b88abc66f82c4287eccbae5ecd950..40567491e6912ca9bdc91956cc83ca23f8355752 100644
--- a/backend/RTLtyping.v
+++ b/backend/RTLtyping.v
@@ -1,6 +1,7 @@
(** Typing rules and a type inference algorithm for RTL. *)
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import AST.
Require Import Op.
@@ -22,15 +23,17 @@ Require Conventions.
enabling each pseudo-register to be mapped to a single hardware register
or stack location of the correct type.
-
- The typing judgement for instructions is of the form [wt_instr f env instr],
- where [f] is the current function (used to type-check [Ireturn]
- instructions) and [env] is a typing environment associating types to
- pseudo-registers. Since pseudo-registers have unique types throughout
- the function, the typing environment does not change during type-checking
- of individual instructions. One point to note is that we have two
- polymorphic operators, [Omove] and [Oundef], which can work both
- over integers and floats.
+ Finally, we also check that the successors of instructions
+ are valid, i.e. refer to non-empty nodes in the CFG.
+
+ The typing judgement for instructions is of the form [wt_instr f env
+ instr], where [f] is the current function (used to type-check
+ [Ireturn] instructions) and [env] is a typing environment
+ associating types to pseudo-registers. Since pseudo-registers have
+ unique types throughout the function, the typing environment does
+ not change during type-checking of individual instructions. One
+ point to note is that we have one polymorphic operator, [Omove],
+ which can work over both integers and floats.
*)
Definition regenv := reg -> typ.
@@ -38,51 +41,67 @@ Definition regenv := reg -> typ.
Section WT_INSTR.
Variable env: regenv.
-Variable funsig: signature.
+Variable funct: function.
+
+Definition valid_successor (s: node) : Prop :=
+ exists i, funct.(fn_code)!s = Some i.
Inductive wt_instr : instruction -> Prop :=
| wt_Inop:
forall s,
+ valid_successor s ->
wt_instr (Inop s)
| wt_Iopmove:
forall r1 r s,
env r1 = env r ->
+ valid_successor s ->
wt_instr (Iop Omove (r1 :: nil) r s)
- | wt_Iopundef:
- forall r s,
- wt_instr (Iop Oundef nil r s)
| wt_Iop:
forall op args res s,
- op <> Omove -> op <> Oundef ->
+ op <> Omove ->
(List.map env args, env res) = type_of_operation op ->
+ valid_successor s ->
wt_instr (Iop op args res s)
| wt_Iload:
forall chunk addr args dst s,
List.map env args = type_of_addressing addr ->
env dst = type_of_chunk chunk ->
+ valid_successor s ->
wt_instr (Iload chunk addr args dst s)
| wt_Istore:
forall chunk addr args src s,
List.map env args = type_of_addressing addr ->
env src = type_of_chunk chunk ->
+ valid_successor s ->
wt_instr (Istore chunk addr args src s)
| wt_Icall:
forall sig ros args res s,
match ros with inl r => env r = Tint | inr s => True end ->
List.map env args = sig.(sig_args) ->
- env res = match sig.(sig_res) with None => Tint | Some ty => ty end ->
+ env res = proj_sig_res sig ->
+ valid_successor s ->
wt_instr (Icall sig ros args res s)
+ | wt_Itailcall:
+ forall sig ros args,
+ match ros with inl r => env r = Tint | inr s => True end ->
+ sig.(sig_res) = funct.(fn_sig).(sig_res) ->
+ List.map env args = sig.(sig_args) ->
+ Conventions.tailcall_possible sig ->
+ wt_instr (Itailcall sig ros args)
| wt_Ialloc:
forall arg res s,
env arg = Tint -> env res = Tint ->
+ valid_successor s ->
wt_instr (Ialloc arg res s)
| wt_Icond:
forall cond args s1 s2,
List.map env args = type_of_condition cond ->
+ valid_successor s1 ->
+ valid_successor s2 ->
wt_instr (Icond cond args s1 s2)
| wt_Ireturn:
forall optres,
- option_map env optres = funsig.(sig_res) ->
+ option_map env optres = funct.(fn_sig).(sig_res) ->
wt_instr (Ireturn optres).
End WT_INSTR.
@@ -90,7 +109,7 @@ End WT_INSTR.
(** A function [f] is well-typed w.r.t. a typing environment [env],
written [wt_function env f], if all instructions are well-typed,
parameters agree in types with the function signature, and
- names of parameters are pairwise distinct. *)
+ parameters are pairwise distinct. *)
Record wt_function (f: function) (env: regenv): Prop :=
mk_wt_function {
@@ -100,7 +119,9 @@ Record wt_function (f: function) (env: regenv): Prop :=
list_norepet f.(fn_params);
wt_instrs:
forall pc instr,
- f.(fn_code)!pc = Some instr -> wt_instr env f.(fn_sig) instr
+ f.(fn_code)!pc = Some instr -> wt_instr env f instr;
+ wt_entrypoint:
+ valid_successor f f.(fn_entrypoint)
}.
Inductive wt_fundef: fundef -> Prop :=
@@ -142,6 +163,9 @@ Variable env: regenv.
Lemma typ_eq: forall (t1 t2: typ), {t1=t2} + {t1<>t2}.
Proof. decide equality. Qed.
+Lemma opt_typ_eq: forall (t1 t2: option typ), {t1=t2} + {t1<>t2}.
+Proof. decide equality. apply typ_eq. Qed.
+
Definition check_reg (r: reg) (ty: typ): bool :=
if typ_eq (env r) ty then true else false.
@@ -156,34 +180,47 @@ Definition check_op (op: operation) (args: list reg) (res: reg): bool :=
let (targs, tres) := type_of_operation op in
check_regs args targs && check_reg res tres.
+Definition check_successor (s: node) : bool :=
+ match funct.(fn_code)!s with None => false | Some i => true end.
+
Definition check_instr (i: instruction) : bool :=
match i with
- | Inop _ =>
- true
- | Iop Omove (arg::nil) res _ =>
- if typ_eq (env arg) (env res) then true else false
- | Iop Omove args res _ =>
- false
- | Iop Oundef nil res _ =>
- true
- | Iop Oundef args res _ =>
+ | Inop s =>
+ check_successor s
+ | Iop Omove (arg::nil) res s =>
+ if typ_eq (env arg) (env res)
+ then check_successor s
+ else false
+ | Iop Omove args res s =>
false
- | Iop op args res _ =>
- check_op op args res
- | Iload chunk addr args dst _ =>
+ | Iop op args res s =>
+ check_op op args res && check_successor s
+ | Iload chunk addr args dst s =>
check_regs args (type_of_addressing addr)
&& check_reg dst (type_of_chunk chunk)
- | Istore chunk addr args src _ =>
+ && check_successor s
+ | Istore chunk addr args src s =>
check_regs args (type_of_addressing addr)
&& check_reg src (type_of_chunk chunk)
- | Icall sig ros args res _ =>
+ && check_successor s
+ | Icall sig ros args res s =>
+ match ros with inl r => check_reg r Tint | inr s => true end
+ && check_regs args sig.(sig_args)
+ && check_reg res (proj_sig_res sig)
+ && check_successor s
+ | Itailcall sig ros args =>
match ros with inl r => check_reg r Tint | inr s => true end
&& check_regs args sig.(sig_args)
- && check_reg res (match sig.(sig_res) with None => Tint | Some ty => ty end)
- | Ialloc arg res _ =>
- check_reg arg Tint && check_reg res Tint
- | Icond cond args _ _ =>
+ && opt_typ_eq sig.(sig_res) funct.(fn_sig).(sig_res)
+ && zeq (Conventions.size_arguments sig) 14
+ | Ialloc arg res s =>
+ check_reg arg Tint
+ && check_reg res Tint
+ && check_successor s
+ | Icond cond args s1 s2 =>
check_regs args (type_of_condition cond)
+ && check_successor s1
+ && check_successor s2
| Ireturn optres =>
match optres, funct.(fn_sig).(sig_res) with
| None, None => true
@@ -203,6 +240,14 @@ Fixpoint check_instrs (instrs: list (node * instruction)) : bool :=
(** ** Correctness of the type-checking algorithm *)
+Ltac elimAndb :=
+ match goal with
+ | [ H: _ && _ = true |- _ ] =>
+ elim (andb_prop _ _ H); clear H; intros; elimAndb
+ | _ =>
+ idtac
+ end.
+
Lemma check_reg_correct:
forall r ty, check_reg r ty = true -> env r = ty.
Proof.
@@ -215,8 +260,8 @@ Lemma check_regs_correct:
Proof.
induction rl; destruct tyl; simpl; intros.
auto. discriminate. discriminate.
- elim (andb_prop _ _ H); intros.
- rewrite (check_reg_correct _ _ H0). rewrite (IHrl tyl H1). auto.
+ elimAndb.
+ rewrite (check_reg_correct _ _ H). rewrite (IHrl tyl H0). auto.
Qed.
Lemma check_op_correct:
@@ -225,45 +270,65 @@ Lemma check_op_correct:
(List.map env args, env res) = type_of_operation op.
Proof.
unfold check_op; intros.
- destruct (type_of_operation op) as [targs tres].
- elim (andb_prop _ _ H); intros.
- rewrite (check_regs_correct _ _ H0).
- rewrite (check_reg_correct _ _ H1).
+ destruct (type_of_operation op) as [targs tres].
+ elimAndb.
+ rewrite (check_regs_correct _ _ H).
+ rewrite (check_reg_correct _ _ H0).
auto.
Qed.
+Lemma check_successor_correct:
+ forall s,
+ check_successor s = true -> valid_successor funct s.
+Proof.
+ intro; unfold check_successor, valid_successor.
+ destruct (fn_code funct)!s; intro.
+ exists i; auto.
+ discriminate.
+Qed.
+
Lemma check_instr_correct:
- forall i, check_instr i = true -> wt_instr env funct.(fn_sig) i.
+ forall i, check_instr i = true -> wt_instr env funct i.
Proof.
- unfold check_instr; intros; destruct i.
+ unfold check_instr; intros; destruct i; elimAndb.
(* nop *)
- constructor.
+ constructor. apply check_successor_correct; auto.
(* op *)
- destruct o;
- try (apply wt_Iop; [congruence|congruence|apply check_op_correct;auto]).
+ destruct o; elimAndb;
+ try (apply wt_Iop; [ congruence
+ | apply check_op_correct; auto
+ | apply check_successor_correct; auto ]).
destruct l; try discriminate. destruct l; try discriminate.
destruct (typ_eq (env r0) (env r)); try discriminate.
- apply wt_Iopmove; auto.
- destruct l; try discriminate.
- apply wt_Iopundef.
+ apply wt_Iopmove; auto. apply check_successor_correct; auto.
(* load *)
- elim (andb_prop _ _ H); intros.
constructor. apply check_regs_correct; auto. apply check_reg_correct; auto.
+ apply check_successor_correct; auto.
(* store *)
- elim (andb_prop _ _ H); intros.
constructor. apply check_regs_correct; auto. apply check_reg_correct; auto.
+ apply check_successor_correct; auto.
(* call *)
- elim (andb_prop _ _ H); clear H; intros.
- elim (andb_prop _ _ H); clear H; intros.
constructor.
destruct s0; auto. apply check_reg_correct; auto.
apply check_regs_correct; auto.
apply check_reg_correct; auto.
+ apply check_successor_correct; auto.
+ (* tailcall *)
+ constructor.
+ destruct s0; auto. apply check_reg_correct; auto.
+ eapply proj_sumbool_true; eauto.
+ apply check_regs_correct; auto.
+ rewrite Conventions.tailcall_possible_size.
+ eapply proj_sumbool_true; eauto.
(* alloc *)
- elim (andb_prop _ _ H); intros.
- constructor; apply check_reg_correct; auto.
+ constructor.
+ apply check_reg_correct; auto.
+ apply check_reg_correct; auto.
+ apply check_successor_correct; auto.
(* cond *)
constructor. apply check_regs_correct; auto.
+ apply check_successor_correct; auto.
+ apply check_successor_correct; auto.
(* return *)
constructor.
destruct o; simpl; destruct funct.(fn_sig).(sig_res); try discriminate.
@@ -274,11 +339,11 @@ Qed.
Lemma check_instrs_correct:
forall instrs,
check_instrs instrs = true ->
- forall pc i, In (pc, i) instrs -> wt_instr env funct.(fn_sig) i.
+ forall pc i, In (pc, i) instrs -> wt_instr env funct i.
Proof.
induction instrs; simpl; intros.
elim H0.
- destruct a as [pc' i']. elim (andb_prop _ _ H); clear H; intros.
+ destruct a as [pc' i']. elimAndb.
elim H0; intro.
inversion H2; subst pc' i'. apply check_instr_correct; auto.
eauto.
@@ -288,20 +353,24 @@ End TYPECHECKING.
(** ** The type inference function **)
-Definition type_function (f: function): option regenv :=
+Open Scope string_scope.
+
+Definition type_function (f: function): res regenv :=
let instrs := PTree.elements f.(fn_code) in
match infer_type_environment f instrs with
- | None => None
+ | None => Error (msg "RTL type inference error")
| Some env =>
if check_regs env f.(fn_params) f.(fn_sig).(sig_args)
&& check_params_norepet f.(fn_params)
&& check_instrs f env instrs
- then Some env else None
+ && check_successor f f.(fn_entrypoint)
+ then OK env
+ else Error (msg "RTL type checking error")
end.
Lemma type_function_correct:
forall f env,
- type_function f = Some env ->
+ type_function f = OK env ->
wt_function f env.
Proof.
unfold type_function; intros until env.
@@ -311,6 +380,7 @@ Proof.
caseEq (check_regs env' f.(fn_params) f.(fn_sig).(sig_args)); intro; simpl; try congruence.
caseEq (check_params_norepet f.(fn_params)); intro; simpl; try congruence.
caseEq (check_instrs f env' instrs); intro; simpl; try congruence.
+ caseEq (check_successor f (fn_entrypoint f)); intro; simpl; try congruence.
intro EQ; inversion EQ; subst env'.
constructor.
apply check_regs_correct; auto.
@@ -318,6 +388,7 @@ Proof.
destruct (list_norepet_dec Reg.eq (fn_params f)). auto. discriminate.
intros. eapply check_instrs_correct. eauto.
unfold instrs. apply PTree.elements_correct. eauto.
+ apply check_successor_correct. auto.
congruence.
Qed.
@@ -330,7 +401,8 @@ Qed.
property: if the execution does not fail because of a failed run-time
test, the result values and register states match the static
typing assumptions. This preservation property will be useful
- later for the proof of semantic equivalence between [Machabstr] and [Mach].
+ later for the proof of semantic equivalence between
+ [Machabstr] and [Machconcr].
Even though we do not need it for [RTL], we show preservation for [RTL]
here, as a warm-up exercise and because some of the lemmas will be
useful later. *)
@@ -340,6 +412,7 @@ Require Import Values.
Require Import Mem.
Require Import Integers.
Require Import Events.
+Require Import Smallstep.
Definition wt_regset (env: regenv) (rs: regset) : Prop :=
forall r, Val.has_type (rs#r) (env r).
@@ -385,6 +458,36 @@ Proof.
induction 1. inversion H0; exact I.
Qed.
+Inductive wt_stackframes: list stackframe -> option typ -> Prop :=
+ | wt_stackframes_nil:
+ wt_stackframes nil (Some Tint)
+ | wt_stackframes_cons:
+ forall s res f sp pc rs env tyres,
+ wt_function f env ->
+ wt_regset env rs ->
+ env res = match tyres with None => Tint | Some t => t end ->
+ wt_stackframes s (sig_res (fn_sig f)) ->
+ wt_stackframes (Stackframe res (fn_code f) sp pc rs :: s) tyres.
+
+Inductive wt_state: state -> Prop :=
+ | wt_state_intro:
+ forall s f sp pc rs m env
+ (WT_STK: wt_stackframes s (sig_res (fn_sig f)))
+ (WT_FN: wt_function f env)
+ (WT_RS: wt_regset env rs),
+ wt_state (State s (fn_code f) sp pc rs m)
+ | wt_state_call:
+ forall s f args m,
+ wt_stackframes s (sig_res (funsig f)) ->
+ wt_fundef f ->
+ Val.has_type_list args (sig_args (funsig f)) ->
+ wt_state (Callstate s f args m)
+ | wt_state_return:
+ forall s v m tyres,
+ wt_stackframes s tyres ->
+ Val.has_type v (match tyres with None => Tint | Some t => t end) ->
+ wt_state (Returnstate s v m).
+
Section SUBJECT_REDUCTION.
Variable p: program.
@@ -393,90 +496,77 @@ Hypothesis wt_p: wt_program p.
Let ge := Genv.globalenv p.
-Definition exec_instr_subject_reduction
- (c: code) (sp: val)
- (pc: node) (rs: regset) (m: mem) (t: trace)
- (pc': node) (rs': regset) (m': mem) : Prop :=
- forall env f
- (CODE: c = fn_code f)
- (WT_FN: wt_function f env)
- (WT_RS: wt_regset env rs),
- wt_regset env rs'.
-
-Definition exec_function_subject_reduction
- (f: fundef) (args: list val) (m: mem) (t: trace) (res: val) (m': mem) : Prop :=
- wt_fundef f ->
- Val.has_type_list args (sig_args (funsig f)) ->
- Val.has_type res (proj_sig_res (funsig f)).
-
Lemma subject_reduction:
- forall f args m t res m',
- exec_function ge f args m t res m' ->
- exec_function_subject_reduction f args m t res m'.
+ forall st1 t st2, step ge st1 t st2 ->
+ forall (WT: wt_state st1), wt_state st2.
Proof.
- apply (exec_function_ind_3 ge
- exec_instr_subject_reduction
- exec_instr_subject_reduction
- exec_function_subject_reduction);
- intros; red; intros;
- try (rewrite CODE in H;
- generalize (wt_instrs _ _ WT_FN pc _ H);
+ induction 1; intros; inv WT;
+ try (generalize (wt_instrs _ _ WT_FN pc _ H);
intro WT_INSTR;
- inversion WT_INSTR).
-
- assumption.
-
+ inv WT_INSTR).
+ (* Inop *)
+ econstructor; eauto.
+ (* Iop *)
+ econstructor; eauto.
apply wt_regset_assign. auto.
- subst op. subst args. simpl in H0. injection H0; intro.
- subst v. rewrite <- H2. apply WT_RS.
-
- apply wt_regset_assign. auto.
- subst op; subst args; simpl in H0. injection H0; intro; subst v.
- simpl; auto.
-
+ simpl in H0. inv H0. rewrite <- H3. apply WT_RS.
+ econstructor; eauto.
apply wt_regset_assign. auto.
replace (env res) with (snd (type_of_operation op)).
- apply type_of_operation_sound with fundef ge rs##args sp; auto.
- rewrite <- H7. reflexivity.
-
+ apply type_of_operation_sound with fundef ge rs##args sp m; auto.
+ rewrite <- H6. reflexivity.
+ (* Iload *)
+ econstructor; eauto.
apply wt_regset_assign. auto. rewrite H8.
eapply type_of_chunk_correct; eauto.
-
- assumption.
-
- apply wt_regset_assign. auto. rewrite H11. rewrite <- H1.
+ (* Istore *)
+ econstructor; eauto.
+ (* Icall *)
assert (wt_fundef f).
destruct ros; simpl in H0.
pattern f. apply Genv.find_funct_prop with fundef unit p (rs#r).
exact wt_p. exact H0.
- caseEq (Genv.find_symbol ge i); intros; rewrite H12 in H0.
+ caseEq (Genv.find_symbol ge i); intros; rewrite H1 in H0.
pattern f. apply Genv.find_funct_ptr_prop with fundef unit p b.
exact wt_p. exact H0.
discriminate.
- eapply H3. auto. rewrite H1. rewrite <- H10.
- apply wt_regset_list; auto.
-
- apply wt_regset_assign. auto. rewrite H6; exact I.
-
- assumption.
- assumption.
- assumption.
- eauto.
- eauto.
-
- inversion H4; subst f0.
- assert (WT_INIT: wt_regset env (init_regs args (fn_params f))).
- apply wt_init_regs. rewrite (wt_params _ _ H7). assumption.
- generalize (H1 env f (refl_equal (fn_code f)) H7 WT_INIT).
- intro WT_RS.
- generalize (wt_instrs _ _ H7 pc _ H2).
- intro WT_INSTR; inversion WT_INSTR.
- unfold proj_sig_res; simpl.
- destruct or; simpl in H3; simpl in H8; rewrite <- H8.
- rewrite H3. apply WT_RS.
- rewrite H3. simpl; auto.
-
- simpl. eapply wt_event_match; eauto.
-Qed.
+ econstructor; eauto.
+ econstructor; eauto.
+ rewrite <- H7. apply wt_regset_list. auto.
+ (* Itailcall *)
+ assert (wt_fundef f).
+ destruct ros; simpl in H0.
+ pattern f. apply Genv.find_funct_prop with fundef unit p (rs#r).
+ exact wt_p. exact H0.
+ caseEq (Genv.find_symbol ge i); intros; rewrite H1 in H0.
+ pattern f. apply Genv.find_funct_ptr_prop with fundef unit p b.
+ exact wt_p. exact H0.
+ discriminate.
+ econstructor; eauto.
+ rewrite H5; auto.
+ rewrite <- H6. apply wt_regset_list. auto.
+ (* Ialloc *)
+ econstructor; eauto.
+ apply wt_regset_assign. auto. rewrite H6; exact I.
+ (* Icond *)
+ econstructor; eauto.
+ econstructor; eauto.
+ (* Ireturn *)
+ econstructor; eauto.
+ destruct or; simpl in *.
+ rewrite <- H1. apply WT_RS. exact I.
+ (* internal function *)
+ simpl in *. inv H5. inversion H1; subst.
+ econstructor; eauto.
+ apply wt_init_regs; auto. rewrite wt_params0; auto.
+ (* external function *)
+ simpl in *. inv H5.
+ econstructor; eauto.
+ change (Val.has_type res (proj_sig_res (ef_sig ef))).
+ eapply wt_event_match; eauto.
+ (* return *)
+ inv H1. econstructor; eauto.
+ apply wt_regset_assign; auto. congruence.
+Qed.
End SUBJECT_REDUCTION.
diff --git a/backend/Registers.v b/backend/Registers.v
index 578e4b87d6af315cb1dc30004774b98cb5d51965..e4b7b000b5f53811fe5e6bb3fd73cecfbd667dab 100644
--- a/backend/Registers.v
+++ b/backend/Registers.v
@@ -1,8 +1,9 @@
(** Pseudo-registers and register states.
- This library defines the type of pseudo-registers used in the RTL
- intermediate language, and of mappings from pseudo-registers to
- values as used in the dynamic semantics of RTL. *)
+ This library defines the type of pseudo-registers (also known as
+ "temporaries" in compiler literature) used in the RTL
+ intermediate language. We also define finite sets and finite maps
+ over pseudo-registers. *)
Require Import Coqlib.
Require Import AST.
diff --git a/backend/Reload.v b/backend/Reload.v
new file mode 100644
index 0000000000000000000000000000000000000000..58e17ff52253595d51988a9e87377dde30a98604
--- /dev/null
+++ b/backend/Reload.v
@@ -0,0 +1,211 @@
+(** Reloading, spilling, and explication of calling conventions. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Integers.
+Require Import Values.
+Require Import Globalenvs.
+Require Import Op.
+Require Import Locations.
+Require Import LTLin.
+Require Import Conventions.
+Require Import Parallelmove.
+Require Import Linear.
+
+(** * Spilling and reloading *)
+
+(** Operations in the Linear language, like those of the target processor,
+ operate only over machine registers, but not over stack slots.
+ Consider the LTLin instruction
+<<
+ r1 <- Lop(Oadd, r1 :: r2 :: nil)
+>>
+ and assume that [r1] and [r2] are assigned to stack locations [S s1]
+ and [S s2], respectively. The translated LTL code must load these
+ stack locations into temporary integer registers (this is called
+ ``reloading''), perform the [Oadd] operation over these temporaries,
+ leave the result in a temporary, then store the temporary back to
+ stack location [S s1] (this is called ``spilling''). In other term,
+ the generated Linear code has the following shape:
+<<
+ IT1 <- Lgetstack s1;
+ IT2 <- Lgetstack s2;
+ IT1 <- Lop(Oadd, IT1 :: IT2 :: nil);
+ Lsetstack s1 IT1;
+>>
+ This section provides functions that assist in choosing appropriate
+ temporaries and inserting the required spilling and reloading
+ operations. *)
+
+(** ** Allocation of temporary registers for reloading and spilling. *)
+
+(** [reg_for l] returns a machine register appropriate for working
+ over the location [l]: either the machine register [m] if [l = R m],
+ or a temporary register of [l]'s type if [l] is a stack slot. *)
+
+Definition reg_for (l: loc) : mreg :=
+ match l with
+ | R r => r
+ | S s => match slot_type s with Tint => IT1 | Tfloat => FT1 end
+ end.
+
+(** [regs_for ll] is similar, for a list of locations [ll] of length
+ at most 3. We ensure that distinct temporaries are used for
+ different elements of [ll]. *)
+
+Fixpoint regs_for_rec (locs: list loc) (itmps ftmps: list mreg)
+ {struct locs} : list mreg :=
+ match locs, itmps, ftmps with
+ | l1 :: ls, it1 :: its, ft1 :: fts =>
+ match l1 with
+ | R r => r
+ | S s => match slot_type s with Tint => it1 | Tfloat => ft1 end
+ end
+ :: regs_for_rec ls its fts
+ | _, _, _ => nil
+ end.
+
+Definition regs_for (locs: list loc) :=
+ regs_for_rec locs (IT1 :: IT2 :: IT3 :: nil) (FT1 :: FT2 :: FT3 :: nil).
+
+(** ** Insertion of Linear reloads, stores and moves *)
+
+(** [add_spill src dst k] prepends to [k] the instructions needed
+ to assign location [dst] the value of machine register [mreg]. *)
+
+Definition add_spill (src: mreg) (dst: loc) (k: code) :=
+ match dst with
+ | R rd => if mreg_eq src rd then k else Lop Omove (src :: nil) rd :: k
+ | S sl => Lsetstack src sl :: k
+ end.
+
+(** [add_reload src dst k] prepends to [k] the instructions needed
+ to assign machine register [mreg] the value of the location [src]. *)
+
+Definition add_reload (src: loc) (dst: mreg) (k: code) :=
+ match src with
+ | R rs => if mreg_eq rs dst then k else Lop Omove (rs :: nil) dst :: k
+ | S sl => Lgetstack sl dst :: k
+ end.
+
+(** [add_reloads] is similar for a list of locations (as sources)
+ and a list of machine registers (as destinations). *)
+
+Fixpoint add_reloads (srcs: list loc) (dsts: list mreg) (k: code)
+ {struct srcs} : code :=
+ match srcs, dsts with
+ | s1 :: sl, t1 :: tl => add_reload s1 t1 (add_reloads sl tl k)
+ | _, _ => k
+ end.
+
+(** [add_move src dst k] prepends to [k] the instructions that copy
+ the value of location [src] into location [dst]. *)
+
+Definition add_move (src dst: loc) (k: code) :=
+ if Loc.eq src dst then k else
+ match src, dst with
+ | R rs, _ =>
+ add_spill rs dst k
+ | _, R rd =>
+ add_reload src rd k
+ | S ss, S sd =>
+ let tmp :=
+ match slot_type ss with Tint => IT1 | Tfloat => FT1 end in
+ add_reload src tmp (add_spill tmp dst k)
+ end.
+
+(** [parallel_move srcs dsts k] is similar, but for a list of
+ source locations and a list of destination locations of the same
+ length. This is a parallel move, meaning that some of the
+ destinations can also occur as sources. *)
+
+Definition parallel_move (srcs dsts: list loc) (k: code) : code :=
+ List.fold_right
+ (fun p k => add_move (fst p) (snd p) k)
+ k (parmove srcs dsts).
+
+(** * Code transformation *)
+
+(** We insert appropriate reload, spill and parallel move operations
+ around each of the instructions of the source code. *)
+
+Definition transf_instr
+ (f: LTLin.function) (instr: LTLin.instruction) (k: code) : code :=
+ match instr with
+ | LTLin.Lop op args res =>
+ match is_move_operation op args with
+ | Some src =>
+ add_move src res k
+ | None =>
+ let rargs := regs_for args in
+ let rres := reg_for res in
+ add_reloads args rargs (Lop op rargs rres :: add_spill rres res k)
+ end
+ | LTLin.Lload chunk addr args dst =>
+ let rargs := regs_for args in
+ let rdst := reg_for dst in
+ add_reloads args rargs
+ (Lload chunk addr rargs rdst :: add_spill rdst dst k)
+ | LTLin.Lstore chunk addr args src =>
+ match regs_for (src :: args) with
+ | nil => nil (* never happens *)
+ | rsrc :: rargs =>
+ add_reloads (src :: args) (rsrc :: rargs)
+ (Lstore chunk addr rargs rsrc :: k)
+ end
+ | LTLin.Lcall sig los args res =>
+ let largs := loc_arguments sig in
+ let rres := loc_result sig in
+ match los with
+ | inl fn =>
+ add_reload fn IT3
+ (parallel_move args largs
+ (Lcall sig (inl _ IT3) :: add_spill rres res k))
+ | inr id =>
+ parallel_move args largs
+ (Lcall sig (inr _ id) :: add_spill rres res k)
+ end
+ | LTLin.Ltailcall sig los args =>
+ let largs := loc_arguments sig in
+ match los with
+ | inl fn =>
+ add_reload fn IT3
+ (parallel_move args largs
+ (Ltailcall sig (inl _ IT3) :: k))
+ | inr id =>
+ parallel_move args largs
+ (Ltailcall sig (inr _ id) :: k)
+ end
+ | LTLin.Lalloc arg res =>
+ add_reload arg loc_alloc_argument
+ (Lalloc :: add_spill loc_alloc_result res k)
+ | LTLin.Llabel lbl =>
+ Llabel lbl :: k
+ | LTLin.Lgoto lbl =>
+ Lgoto lbl :: k
+ | LTLin.Lcond cond args lbl =>
+ let rargs := regs_for args in
+ add_reloads args rargs (Lcond cond rargs lbl :: k)
+ | LTLin.Lreturn None =>
+ Lreturn :: k
+ | LTLin.Lreturn (Some loc) =>
+ add_reload loc (loc_result (LTLin.fn_sig f)) (Lreturn :: k)
+ end.
+
+Definition transf_code (f: LTLin.function) (c: LTLin.code) : code :=
+ List.fold_right (transf_instr f) nil c.
+
+Definition transf_function (f: LTLin.function) : function :=
+ mkfunction
+ (LTLin.fn_sig f)
+ (LTLin.fn_stacksize f)
+ (parallel_move (loc_parameters (LTLin.fn_sig f)) (LTLin.fn_params f)
+ (transf_code f (LTLin.fn_code f))).
+
+Definition transf_fundef (fd: LTLin.fundef) : Linear.fundef :=
+ transf_fundef transf_function fd.
+
+Definition transf_program (p: LTLin.program) : Linear.program :=
+ transform_program transf_fundef p.
+
diff --git a/backend/Reloadproof.v b/backend/Reloadproof.v
new file mode 100644
index 0000000000000000000000000000000000000000..e9ced51f9acb1153cb030b8893ff1a6ac30827ba
--- /dev/null
+++ b/backend/Reloadproof.v
@@ -0,0 +1,1230 @@
+(** Correctness proof for the [Reload] pass. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Integers.
+Require Import Values.
+Require Import Mem.
+Require Import Events.
+Require Import Globalenvs.
+Require Import Smallstep.
+Require Import Op.
+Require Import Locations.
+Require Import Conventions.
+Require Import Allocproof.
+Require Import LTLin.
+Require Import LTLintyping.
+Require Import Linear.
+Require Import Parallelmove.
+Require Import Reload.
+
+(** * Exploitation of the typing hypothesis *)
+
+(** Reloading is applied to LTLin code that is well-typed in
+ the sense of [LTLintyping]. We exploit this hypothesis to obtain information on
+ the number of arguments to operations, addressing modes and conditions. *)
+
+Remark length_type_of_condition:
+ forall (c: condition), (List.length (type_of_condition c) <= 3)%nat.
+Proof.
+ destruct c; unfold type_of_condition; simpl; omega.
+Qed.
+
+Remark length_type_of_operation:
+ forall (op: operation), (List.length (fst (type_of_operation op)) <= 3)%nat.
+Proof.
+ destruct op; unfold type_of_operation; simpl; try omega.
+ apply length_type_of_condition.
+Qed.
+
+Remark length_type_of_addressing:
+ forall (addr: addressing), (List.length (type_of_addressing addr) <= 2)%nat.
+Proof.
+ destruct addr; unfold type_of_addressing; simpl; omega.
+Qed.
+
+Lemma length_op_args:
+ forall (op: operation) (args: list loc) (res: loc),
+ (List.map Loc.type args, Loc.type res) = type_of_operation op ->
+ (List.length args <= 3)%nat.
+Proof.
+ intros. rewrite <- (list_length_map Loc.type).
+ generalize (length_type_of_operation op).
+ rewrite <- H. simpl. auto.
+Qed.
+
+Lemma length_addr_args:
+ forall (addr: addressing) (args: list loc),
+ List.map Loc.type args = type_of_addressing addr ->
+ (List.length args <= 2)%nat.
+Proof.
+ intros. rewrite <- (list_length_map Loc.type).
+ rewrite H. apply length_type_of_addressing.
+Qed.
+
+Lemma length_cond_args:
+ forall (cond: condition) (args: list loc),
+ List.map Loc.type args = type_of_condition cond ->
+ (List.length args <= 3)%nat.
+Proof.
+ intros. rewrite <- (list_length_map Loc.type).
+ rewrite H. apply length_type_of_condition.
+Qed.
+
+(** * Correctness of the Linear constructors *)
+
+(** This section proves theorems that establish the correctness of the
+ Linear constructor functions such as [add_move]. The theorems are of
+ the general form ``the generated Linear instructions execute and
+ modify the location set in the expected way: the result location(s)
+ contain the expected values; other, non-temporary locations keep
+ their values''. *)
+
+Section LINEAR_CONSTRUCTORS.
+
+Variable ge: genv.
+Variable stk: list stackframe.
+Variable f: function.
+Variable sp: val.
+
+Lemma reg_for_spec:
+ forall l,
+ R(reg_for l) = l \/ In (R (reg_for l)) temporaries.
+Proof.
+ intros. unfold reg_for. destruct l. tauto.
+ case (slot_type s); simpl; tauto.
+Qed.
+
+Lemma reg_for_diff:
+ forall l l',
+ Loc.diff l l' -> Loc.notin l' temporaries ->
+ Loc.diff (R (reg_for l)) l'.
+Proof.
+ intros. destruct (reg_for_spec l).
+ rewrite H1; auto.
+ apply Loc.diff_sym. eapply Loc.in_notin_diff; eauto.
+Qed.
+
+Lemma add_reload_correct:
+ forall src dst k rs m,
+ exists rs',
+ star step ge (State stk f sp (add_reload src dst k) rs m)
+ E0 (State stk f sp k rs' m) /\
+ rs' (R dst) = rs src /\
+ forall l, Loc.diff (R dst) l -> rs' l = rs l.
+Proof.
+ intros. unfold add_reload. destruct src.
+ case (mreg_eq m0 dst); intro.
+ subst dst. exists rs. split. apply star_refl. tauto.
+ exists (Locmap.set (R dst) (rs (R m0)) rs).
+ split. apply star_one; apply exec_Lop. reflexivity.
+ split. apply Locmap.gss.
+ intros; apply Locmap.gso; auto.
+ exists (Locmap.set (R dst) (rs (S s)) rs).
+ split. apply star_one; apply exec_Lgetstack.
+ split. apply Locmap.gss.
+ intros; apply Locmap.gso; auto.
+Qed.
+
+Lemma add_spill_correct:
+ forall src dst k rs m,
+ exists rs',
+ star step ge (State stk f sp (add_spill src dst k) rs m)
+ E0 (State stk f sp k rs' m) /\
+ rs' dst = rs (R src) /\
+ forall l, Loc.diff dst l -> rs' l = rs l.
+Proof.
+ intros. unfold add_spill. destruct dst.
+ case (mreg_eq src m0); intro.
+ subst src. exists rs. split. apply star_refl. tauto.
+ exists (Locmap.set (R m0) (rs (R src)) rs).
+ split. apply star_one. apply exec_Lop. reflexivity.
+ split. apply Locmap.gss.
+ intros; apply Locmap.gso; auto.
+ exists (Locmap.set (S s) (rs (R src)) rs).
+ split. apply star_one. apply exec_Lsetstack.
+ split. apply Locmap.gss.
+ intros; apply Locmap.gso; auto.
+Qed.
+
+Lemma add_reloads_correct_rec:
+ forall srcs itmps ftmps k rs m,
+ (List.length srcs <= List.length itmps)%nat ->
+ (List.length srcs <= List.length ftmps)%nat ->
+ (forall r, In (R r) srcs -> In r itmps -> False) ->
+ (forall r, In (R r) srcs -> In r ftmps -> False) ->
+ list_disjoint itmps ftmps ->
+ list_norepet itmps ->
+ list_norepet ftmps ->
+ exists rs',
+ star step ge
+ (State stk f sp (add_reloads srcs (regs_for_rec srcs itmps ftmps) k) rs m)
+ E0 (State stk f sp k rs' m) /\
+ reglist rs' (regs_for_rec srcs itmps ftmps) = map rs srcs /\
+ (forall r, ~(In r itmps) -> ~(In r ftmps) -> rs' (R r) = rs (R r)) /\
+ (forall s, rs' (S s) = rs (S s)).
+Proof.
+ induction srcs; simpl; intros.
+ (* base case *)
+ exists rs. split. apply star_refl. tauto.
+ (* inductive case *)
+ destruct itmps; simpl in H. omegaContradiction.
+ destruct ftmps; simpl in H0. omegaContradiction.
+ assert (R1: (length srcs <= length itmps)%nat). omega.
+ assert (R2: (length srcs <= length ftmps)%nat). omega.
+ assert (R3: forall r, In (R r) srcs -> In r itmps -> False).
+ intros. apply H1 with r. tauto. auto with coqlib.
+ assert (R4: forall r, In (R r) srcs -> In r ftmps -> False).
+ intros. apply H2 with r. tauto. auto with coqlib.
+ assert (R5: list_disjoint itmps ftmps).
+ eapply list_disjoint_cons_left.
+ eapply list_disjoint_cons_right. eauto.
+ assert (R6: list_norepet itmps).
+ inversion H4; auto.
+ assert (R7: list_norepet ftmps).
+ inversion H5; auto.
+ destruct a.
+ (* a is a register *)
+ generalize (IHsrcs itmps ftmps k rs m R1 R2 R3 R4 R5 R6 R7).
+ intros [rs' [EX [RES [OTH1 OTH2]]]].
+ exists rs'. split.
+ unfold add_reload. case (mreg_eq m2 m2); intro; tauto.
+ split. simpl. apply (f_equal2 (@cons val)).
+ apply OTH1.
+ red; intro; apply H1 with m2. tauto. auto with coqlib.
+ red; intro; apply H2 with m2. tauto. auto with coqlib.
+ assumption.
+ split. intros. apply OTH1. simpl in H6; tauto. simpl in H7; tauto.
+ auto.
+ (* a is a stack location *)
+ set (tmp := match slot_type s with Tint => m0 | Tfloat => m1 end).
+ assert (NI: ~(In tmp itmps)).
+ unfold tmp; case (slot_type s).
+ inversion H4; auto.
+ apply list_disjoint_notin with (m1 :: ftmps).
+ apply list_disjoint_sym. apply list_disjoint_cons_left with m0.
+ auto. auto with coqlib.
+ assert (NF: ~(In tmp ftmps)).
+ unfold tmp; case (slot_type s).
+ apply list_disjoint_notin with (m0 :: itmps).
+ apply list_disjoint_cons_right with m1.
+ auto. auto with coqlib.
+ inversion H5; auto.
+ generalize
+ (add_reload_correct (S s) tmp
+ (add_reloads srcs (regs_for_rec srcs itmps ftmps) k) rs m).
+ intros [rs1 [EX1 [RES1 OTH]]].
+ generalize (IHsrcs itmps ftmps k rs1 m R1 R2 R3 R4 R5 R6 R7).
+ intros [rs' [EX [RES [OTH1 OTH2]]]].
+ exists rs'.
+ split. eapply star_trans; eauto. traceEq.
+ split. simpl. apply (f_equal2 (@cons val)).
+ rewrite OTH1; auto.
+ rewrite RES. apply list_map_exten. intros.
+ symmetry. apply OTH.
+ destruct x; try exact I. simpl. red; intro; subst m2.
+ generalize H6; unfold tmp. case (slot_type s).
+ intro. apply H1 with m0. tauto. auto with coqlib.
+ intro. apply H2 with m1. tauto. auto with coqlib.
+ split. intros. simpl in H6; simpl in H7.
+ rewrite OTH1. apply OTH.
+ simpl. unfold tmp. case (slot_type s); tauto.
+ tauto. tauto.
+ intros. rewrite OTH2. apply OTH. exact I.
+Qed.
+
+Lemma add_reloads_correct:
+ forall srcs k rs m,
+ (List.length srcs <= 3)%nat ->
+ Loc.disjoint srcs temporaries ->
+ exists rs',
+ star step ge (State stk f sp (add_reloads srcs (regs_for srcs) k) rs m)
+ E0 (State stk f sp k rs' m) /\
+ reglist rs' (regs_for srcs) = List.map rs srcs /\
+ forall l, Loc.notin l temporaries -> rs' l = rs l.
+Proof.
+ intros.
+ pose (itmps := IT1 :: IT2 :: IT3 :: nil).
+ pose (ftmps := FT1 :: FT2 :: FT3 :: nil).
+ assert (R1: (List.length srcs <= List.length itmps)%nat).
+ unfold itmps; simpl; assumption.
+ assert (R2: (List.length srcs <= List.length ftmps)%nat).
+ unfold ftmps; simpl; assumption.
+ assert (R3: forall r, In (R r) srcs -> In r itmps -> False).
+ intros. assert (In (R r) temporaries).
+ simpl in H2; simpl; intuition congruence.
+ generalize (H0 _ _ H1 H3). simpl. tauto.
+ assert (R4: forall r, In (R r) srcs -> In r ftmps -> False).
+ intros. assert (In (R r) temporaries).
+ simpl in H2; simpl; intuition congruence.
+ generalize (H0 _ _ H1 H3). simpl. tauto.
+ assert (R5: list_disjoint itmps ftmps).
+ red; intros r1 r2; simpl; intuition congruence.
+ assert (R6: list_norepet itmps).
+ unfold itmps. NoRepet.
+ assert (R7: list_norepet ftmps).
+ unfold ftmps. NoRepet.
+ generalize (add_reloads_correct_rec srcs itmps ftmps k rs m
+ R1 R2 R3 R4 R5 R6 R7).
+ intros [rs' [EX [RES [OTH1 OTH2]]]].
+ exists rs'. split. exact EX.
+ split. exact RES.
+ intros. destruct l. apply OTH1.
+ generalize (Loc.notin_not_in _ _ H1). simpl. intuition congruence.
+ generalize (Loc.notin_not_in _ _ H1). simpl. intuition congruence.
+ apply OTH2.
+Qed.
+
+Lemma add_move_correct:
+ forall src dst k rs m,
+ exists rs',
+ star step ge (State stk f sp (add_move src dst k) rs m)
+ E0 (State stk f sp k rs' m) /\
+ rs' dst = rs src /\
+ forall l, Loc.diff l dst -> Loc.diff l (R IT1) -> Loc.diff l (R FT1) -> rs' l = rs l.
+Proof.
+ intros; unfold add_move.
+ case (Loc.eq src dst); intro.
+ subst dst. exists rs. split. apply star_refl. tauto.
+ destruct src.
+ (* src is a register *)
+ generalize (add_spill_correct m0 dst k rs m); intros [rs' [EX [RES OTH]]].
+ exists rs'; intuition. apply OTH; apply Loc.diff_sym; auto.
+ destruct dst.
+ (* src is a stack slot, dst a register *)
+ generalize (add_reload_correct (S s) m0 k rs m); intros [rs' [EX [RES OTH]]].
+ exists rs'; intuition. apply OTH; apply Loc.diff_sym; auto.
+ (* src and dst are stack slots *)
+ set (tmp := match slot_type s with Tint => IT1 | Tfloat => FT1 end).
+ generalize (add_reload_correct (S s) tmp (add_spill tmp (S s0) k) rs m);
+ intros [rs1 [EX1 [RES1 OTH1]]].
+ generalize (add_spill_correct tmp (S s0) k rs1 m);
+ intros [rs2 [EX2 [RES2 OTH2]]].
+ exists rs2. split.
+ eapply star_trans; eauto. traceEq.
+ split. congruence.
+ intros. rewrite OTH2. apply OTH1.
+ apply Loc.diff_sym. unfold tmp; case (slot_type s); auto.
+ apply Loc.diff_sym; auto.
+Qed.
+
+Lemma effect_move_sequence:
+ forall k moves rs m,
+ let k' := List.fold_right (fun p k => add_move (fst p) (snd p) k) k moves in
+ exists rs',
+ star step ge (State stk f sp k' rs m)
+ E0 (State stk f sp k rs' m) /\
+ effect_seqmove moves rs rs'.
+Proof.
+ induction moves; intros until m; simpl.
+ exists rs; split. constructor. constructor.
+ destruct a as [src dst]; simpl.
+ set (k1 := fold_right
+ (fun (p : loc * loc) (k : code) => add_move (fst p) (snd p) k)
+ k moves) in *.
+ destruct (add_move_correct src dst k1 rs m) as [rs1 [A [B C]]].
+ destruct (IHmoves rs1 m) as [rs' [D E]].
+ exists rs'; split.
+ eapply star_trans; eauto. traceEq.
+ econstructor; eauto. red. tauto.
+Qed.
+
+Lemma parallel_move_correct:
+ forall srcs dsts k rs m,
+ List.length srcs = List.length dsts ->
+ Loc.no_overlap srcs dsts ->
+ Loc.norepet dsts ->
+ Loc.disjoint srcs temporaries ->
+ Loc.disjoint dsts temporaries ->
+ exists rs',
+ star step ge (State stk f sp (parallel_move srcs dsts k) rs m)
+ E0 (State stk f sp k rs' m) /\
+ List.map rs' dsts = List.map rs srcs /\
+ rs' (R IT3) = rs (R IT3) /\
+ forall l, Loc.notin l dsts -> Loc.notin l temporaries -> rs' l = rs l.
+Proof.
+ intros.
+ generalize (effect_move_sequence k (parmove srcs dsts) rs m).
+ intros [rs' [EXEC EFFECT]].
+ exists rs'. split. exact EXEC.
+ apply effect_parmove; auto.
+Qed.
+
+Lemma parallel_move_arguments_correct:
+ forall args sg k rs m,
+ List.map Loc.type args = sg.(sig_args) ->
+ locs_acceptable args ->
+ exists rs',
+ star step ge (State stk f sp (parallel_move args (loc_arguments sg) k) rs m)
+ E0 (State stk f sp k rs' m) /\
+ List.map rs' (loc_arguments sg) = List.map rs args /\
+ rs' (R IT3) = rs (R IT3) /\
+ forall l, Loc.notin l (loc_arguments sg) -> Loc.notin l temporaries -> rs' l = rs l.
+Proof.
+ intros. apply parallel_move_correct.
+ transitivity (length sg.(sig_args)).
+ rewrite <- H. symmetry; apply list_length_map.
+ symmetry. apply loc_arguments_length.
+ apply no_overlap_arguments; auto.
+ apply loc_arguments_norepet.
+ apply locs_acceptable_disj_temporaries; auto.
+ apply loc_arguments_not_temporaries.
+Qed.
+
+Lemma parallel_move_parameters_correct:
+ forall params sg k rs m,
+ List.map Loc.type params = sg.(sig_args) ->
+ locs_acceptable params ->
+ Loc.norepet params ->
+ exists rs',
+ star step ge (State stk f sp (parallel_move (loc_parameters sg) params k) rs m)
+ E0 (State stk f sp k rs' m) /\
+ List.map rs' params = List.map rs (loc_parameters sg) /\
+ rs' (R IT3) = rs (R IT3) /\
+ forall l, Loc.notin l params -> Loc.notin l temporaries -> rs' l = rs l.
+Proof.
+ intros. apply parallel_move_correct.
+ transitivity (length sg.(sig_args)).
+ apply loc_parameters_length.
+ rewrite <- H. apply list_length_map.
+ apply no_overlap_parameters; auto.
+ auto. apply loc_parameters_not_temporaries.
+ apply locs_acceptable_disj_temporaries; auto.
+Qed.
+
+End LINEAR_CONSTRUCTORS.
+
+(** * Agreement between values of locations *)
+
+(** The predicate [agree] states that two location maps
+ give the same values to all acceptable locations,
+ that is, non-temporary registers and [Local] stack slots. *)
+
+Definition agree (rs1 rs2: locset) : Prop :=
+ forall l, loc_acceptable l -> rs2 l = rs1 l.
+
+Lemma agree_loc:
+ forall rs1 rs2 l,
+ agree rs1 rs2 -> loc_acceptable l -> rs2 l = rs1 l.
+Proof.
+ auto.
+Qed.
+
+Lemma agree_locs:
+ forall rs1 rs2 ll,
+ agree rs1 rs2 -> locs_acceptable ll -> map rs2 ll = map rs1 ll.
+Proof.
+ induction ll; simpl; intros.
+ auto.
+ f_equal. apply H. apply H0; auto with coqlib.
+ apply IHll; auto. red; intros. apply H0; auto with coqlib.
+Qed.
+
+Lemma agree_exten:
+ forall rs ls1 ls2,
+ agree rs ls1 ->
+ (forall l, Loc.notin l temporaries -> ls2 l = ls1 l) ->
+ agree rs ls2.
+Proof.
+ intros; red; intros. rewrite H0. auto.
+ apply temporaries_not_acceptable; auto.
+Qed.
+
+Lemma agree_set:
+ forall rs1 rs2 rs2' l v,
+ loc_acceptable l ->
+ rs2' l = v ->
+ (forall l', Loc.diff l l' -> Loc.notin l' temporaries -> rs2' l' = rs2 l') ->
+ agree rs1 rs2 -> agree (Locmap.set l v rs1) rs2'.
+Proof.
+ intros; red; intros.
+ destruct (Loc.eq l l0).
+ subst l0. rewrite Locmap.gss. auto.
+ assert (Loc.diff l l0). eapply loc_acceptable_noteq_diff; eauto.
+ rewrite Locmap.gso; auto. rewrite H1. auto. auto.
+ apply temporaries_not_acceptable; auto.
+Qed.
+
+Lemma agree_return_regs:
+ forall rs1 ls1 rs2 ls2,
+ agree rs1 ls1 -> agree rs2 ls2 ->
+ agree (LTL.return_regs rs1 rs2) (LTL.return_regs ls1 ls2).
+Proof.
+ intros; red; intros. unfold LTL.return_regs.
+ assert (~In l temporaries).
+ apply Loc.notin_not_in. apply temporaries_not_acceptable; auto.
+ destruct l.
+ destruct (In_dec Loc.eq (R m) temporaries). contradiction.
+ destruct (In_dec Loc.eq (R m) destroyed_at_call); auto.
+ auto.
+Qed.
+
+Lemma agree_set_result:
+ forall rs1 ls1 rs2 ls2 sig res ls3,
+ loc_acceptable res -> agree rs1 ls1 -> agree rs2 ls2 ->
+ ls3 res = LTL.return_regs ls1 ls2 (R (loc_result sig)) ->
+ (forall l : loc, Loc.diff res l -> ls3 l = LTL.return_regs ls1 ls2 l) ->
+ let rs_merge := LTL.return_regs rs1 rs2 in
+ agree (Locmap.set res (rs_merge (R (loc_result sig))) rs_merge) ls3.
+Proof.
+ intros. apply agree_set with (LTL.return_regs ls1 ls2); auto.
+ rewrite H2; unfold rs_merge.
+ repeat rewrite return_regs_result. apply H1. apply loc_result_acceptable.
+ unfold rs_merge. apply agree_return_regs; auto.
+Qed.
+
+(** [agree_arguments] and [agree_parameters] are two stronger
+ variants of the predicate [agree]. They additionally demand
+ equality of the values of locations that are arguments or parameters
+ (respectively) for a call to a function of signature [sg]. *)
+
+Definition agree_arguments (sg: signature) (rs1 rs2: locset) : Prop :=
+ forall l, loc_acceptable l \/ In l (loc_arguments sg) -> rs2 l = rs1 l.
+
+Definition agree_parameters (sg: signature) (rs1 rs2: locset) : Prop :=
+ forall l, loc_acceptable l \/ In l (loc_parameters sg) -> rs2 l = rs1 l.
+
+Remark parallel_assignment:
+ forall (P: loc -> Prop) (rs1 rs2 ls1 ls2: locset) srcs dsts,
+ map rs2 dsts = map rs1 srcs ->
+ map ls2 dsts = map ls1 srcs ->
+ (forall l, In l srcs -> P l) ->
+ (forall l, P l -> ls1 l = rs1 l) ->
+ (forall l, In l dsts -> ls2 l = rs2 l).
+Proof.
+ induction srcs; destruct dsts; simpl; intros; try congruence.
+ contradiction.
+ inv H; inv H0. elim H3; intro. subst l0.
+ rewrite H5; rewrite H4. auto with coqlib.
+ eapply IHsrcs; eauto.
+Qed.
+
+Lemma agree_set_arguments:
+ forall rs1 ls1 ls2 args sg,
+ agree rs1 ls1 ->
+ List.map Loc.type args = sg.(sig_args) ->
+ locs_acceptable args ->
+ List.map ls2 (loc_arguments sg) = map ls1 args ->
+ (forall l : loc,
+ Loc.notin l (loc_arguments sg) ->
+ Loc.notin l temporaries -> ls2 l = ls1 l) ->
+ agree_arguments sg (LTL.parmov args (loc_arguments sg) rs1) ls2.
+Proof.
+ intros.
+ assert (Loc.norepet (loc_arguments sg)).
+ apply loc_arguments_norepet.
+ assert (List.length args = List.length (loc_arguments sg)).
+ rewrite loc_arguments_length. rewrite <- H0.
+ symmetry. apply list_length_map.
+ destruct (parmov_spec rs1 _ _ H4 H5) as [A B].
+ set (rs2 := LTL.parmov args (loc_arguments sg) rs1) in *.
+ assert (forall l, In l (loc_arguments sg) -> ls2 l = rs2 l).
+ intros.
+ eapply parallel_assignment with (P := loc_acceptable); eauto.
+ red; intros.
+ destruct (In_dec Loc.eq l (loc_arguments sg)).
+ auto.
+ assert (loc_acceptable l) by tauto.
+ assert (Loc.notin l (loc_arguments sg)).
+ eapply loc_acceptable_notin_notin; eauto.
+ rewrite H3; auto. rewrite B; auto.
+ apply temporaries_not_acceptable; auto.
+Qed.
+
+Lemma agree_arguments_agree:
+ forall sg rs ls, agree_arguments sg rs ls -> agree rs ls.
+Proof.
+ intros; red; intros; auto.
+Qed.
+
+Lemma agree_arguments_locs:
+ forall sg rs1 rs2,
+ agree_arguments sg rs1 rs2 ->
+ map rs2 (loc_arguments sg) = map rs1 (loc_arguments sg).
+Proof.
+ intros.
+ assert (forall ll, incl ll (loc_arguments sg) -> map rs2 ll = map rs1 ll).
+ induction ll; simpl; intros. auto.
+ f_equal. apply H. right. apply H0. auto with coqlib.
+ apply IHll. eapply incl_cons_inv; eauto.
+ apply H0. apply incl_refl.
+Qed.
+
+Lemma agree_set_parameters:
+ forall rs1 ls1 ls2 sg params,
+ agree_parameters sg rs1 ls1 ->
+ List.map Loc.type params = sg.(sig_args) ->
+ locs_acceptable params ->
+ Loc.norepet params ->
+ List.map ls2 params = List.map ls1 (loc_parameters sg) ->
+ (forall l : loc,
+ Loc.notin l params ->
+ Loc.notin l temporaries -> ls2 l = ls1 l) ->
+ agree (LTL.parmov (loc_parameters sg) params rs1) ls2.
+Proof.
+ intros.
+ assert (List.length (loc_parameters sg) = List.length params).
+ unfold loc_parameters. rewrite list_length_map.
+ rewrite loc_arguments_length. rewrite <- H0.
+ apply list_length_map.
+ destruct (parmov_spec rs1 _ _ H2 H5) as [A B].
+ set (rs2 := LTL.parmov (loc_parameters sg) params rs1) in *.
+ red; intros.
+ assert (forall l, In l params -> ls2 l = rs2 l).
+ intros.
+ eapply parallel_assignment with (P := fun l => In l (loc_parameters sg)); eauto.
+ destruct (In_dec Loc.eq l params).
+ auto.
+ assert (Loc.notin l params).
+ eapply loc_acceptable_notin_notin; eauto.
+ rewrite B; auto. rewrite H4; auto.
+ apply temporaries_not_acceptable; auto.
+Qed.
+
+Lemma agree_call_regs:
+ forall sg rs ls,
+ agree_arguments sg rs ls ->
+ agree_parameters sg (LTL.call_regs rs) (LTL.call_regs ls).
+Proof.
+ intros; red; intros. elim H0.
+ destruct l; simpl; auto. destruct s; auto.
+ unfold loc_parameters. intro.
+ destruct (list_in_map_inv _ _ _ H1) as [r [A B]].
+ subst l. generalize (loc_arguments_acceptable _ _ B).
+ destruct r; simpl; auto. destruct s; simpl; auto.
+Qed.
+
+Lemma agree_arguments_return_regs:
+ forall sg rs1 rs2 ls1 ls2,
+ tailcall_possible sg ->
+ agree rs1 ls1 ->
+ agree_arguments sg rs2 ls2 ->
+ agree_arguments sg (LTL.return_regs rs1 rs2) (LTL.return_regs ls1 ls2).
+Proof.
+ intros; red; intros. generalize (H1 l H2). intro.
+ elim H2; intro. generalize (H0 l H4); intro.
+ unfold LTL.return_regs. destruct l; auto.
+ destruct (In_dec Loc.eq (R m) temporaries); auto.
+ destruct (In_dec Loc.eq (R m) destroyed_at_call); auto.
+ generalize (H l H4). unfold LTL.return_regs; destruct l; intro.
+ destruct (In_dec Loc.eq (R m) temporaries); auto.
+ destruct (In_dec Loc.eq (R m) destroyed_at_call); auto.
+ contradiction.
+Qed.
+
+(** * Preservation of labels and gotos *)
+
+Lemma find_label_add_spill:
+ forall lbl src dst k,
+ find_label lbl (add_spill src dst k) = find_label lbl k.
+Proof.
+ intros. destruct dst; simpl; auto.
+ destruct (mreg_eq src m); auto.
+Qed.
+
+Lemma find_label_add_reload:
+ forall lbl src dst k,
+ find_label lbl (add_reload src dst k) = find_label lbl k.
+Proof.
+ intros. destruct src; simpl; auto.
+ destruct (mreg_eq m dst); auto.
+Qed.
+
+Lemma find_label_add_reloads:
+ forall lbl srcs dsts k,
+ find_label lbl (add_reloads srcs dsts k) = find_label lbl k.
+Proof.
+ induction srcs; intros; simpl. auto.
+ destruct dsts; auto. rewrite find_label_add_reload. auto.
+Qed.
+
+Lemma find_label_add_move:
+ forall lbl src dst k,
+ find_label lbl (add_move src dst k) = find_label lbl k.
+Proof.
+ intros; unfold add_move.
+ destruct (Loc.eq src dst); auto.
+ destruct src. apply find_label_add_spill.
+ destruct dst. apply find_label_add_reload.
+ rewrite find_label_add_reload. apply find_label_add_spill.
+Qed.
+
+Lemma find_label_parallel_move:
+ forall lbl srcs dsts k,
+ find_label lbl (parallel_move srcs dsts k) = find_label lbl k.
+Proof.
+ intros. unfold parallel_move. generalize (parmove srcs dsts).
+ induction m; simpl. auto.
+ rewrite find_label_add_move. auto.
+Qed.
+
+Hint Rewrite find_label_add_spill find_label_add_reload
+ find_label_add_reloads find_label_add_move
+ find_label_parallel_move: labels.
+
+Opaque reg_for.
+
+Ltac FL := simpl; autorewrite with labels; auto.
+
+Lemma find_label_transf_instr:
+ forall lbl sg instr k,
+ find_label lbl (transf_instr sg instr k) =
+ if LTLin.is_label lbl instr then Some k else find_label lbl k.
+Proof.
+ intros. destruct instr; FL.
+ destruct (is_move_operation o l); FL; FL.
+ FL.
+ destruct s0; FL; FL; FL.
+ destruct s0; FL; FL; FL.
+ FL.
+ destruct o; FL.
+Qed.
+
+Lemma find_label_transf_code:
+ forall sg lbl c,
+ find_label lbl (transf_code sg c) =
+ option_map (transf_code sg) (LTLin.find_label lbl c).
+Proof.
+ induction c; simpl.
+ auto.
+ rewrite find_label_transf_instr.
+ destruct (LTLin.is_label lbl a); auto.
+Qed.
+
+Lemma find_label_transf_function:
+ forall lbl f c,
+ LTLin.find_label lbl (LTLin.fn_code f) = Some c ->
+ find_label lbl (Linear.fn_code (transf_function f)) =
+ Some (transf_code f c).
+Proof.
+ intros. destruct f; simpl in *. FL.
+ rewrite find_label_transf_code. rewrite H; auto.
+Qed.
+
+(** * Semantic preservation *)
+
+Section PRESERVATION.
+
+Variable prog: LTLin.program.
+Let tprog := transf_program prog.
+Hypothesis WT_PROG: LTLintyping.wt_program prog.
+
+Let ge := Genv.globalenv prog.
+Let tge := Genv.globalenv tprog.
+
+Lemma functions_translated:
+ forall v f,
+ Genv.find_funct ge v = Some f ->
+ Genv.find_funct tge v = Some (transf_fundef f).
+Proof (@Genv.find_funct_transf _ _ _ transf_fundef prog).
+
+Lemma function_ptr_translated:
+ forall v f,
+ Genv.find_funct_ptr ge v = Some f ->
+ Genv.find_funct_ptr tge v = Some (transf_fundef f).
+Proof (@Genv.find_funct_ptr_transf _ _ _ transf_fundef prog).
+
+Lemma symbols_preserved:
+ forall id,
+ Genv.find_symbol tge id = Genv.find_symbol ge id.
+Proof (@Genv.find_symbol_transf _ _ _ transf_fundef prog).
+
+Lemma sig_preserved:
+ forall f, funsig (transf_fundef f) = LTLin.funsig f.
+Proof.
+ destruct f; reflexivity.
+Qed.
+
+Lemma find_function_wt:
+ forall ros rs f,
+ LTLin.find_function ge ros rs = Some f -> wt_fundef f.
+Proof.
+ intros until f. destruct ros; simpl.
+ intro. eapply Genv.find_funct_prop with (p := prog); eauto.
+ caseEq (Genv.find_symbol ge i); intros.
+ eapply Genv.find_funct_ptr_prop with (p := prog); eauto.
+ congruence.
+Qed.
+
+(** The [match_state] predicate relates states in the original LTLin
+ program and the transformed Linear program. The main property
+ it enforces are:
+- Agreement between the values of locations in the two programs,
+ according to the [agree] or [agree_arguments] predicates.
+- Lists of LTLin instructions appearing in the source state
+ are always suffixes of the code for the corresponding functions.
+- Well-typedness of the source code, which ensures that
+ only acceptable locations are accessed by this code.
+*)
+
+Inductive match_stackframes: list LTLin.stackframe -> list Linear.stackframe -> signature -> Prop :=
+ | match_stackframes_nil:
+ forall tyargs,
+ match_stackframes nil nil (mksignature tyargs (Some Tint))
+ | match_stackframes_cons:
+ forall res f sp c rs s s' c' ls sig,
+ match_stackframes s s' (LTLin.fn_sig f) ->
+ c' = add_spill (loc_result sig) res (transf_code f c) ->
+ agree rs ls ->
+ loc_acceptable res ->
+ wt_function f ->
+ is_tail c (LTLin.fn_code f) ->
+ match_stackframes (LTLin.Stackframe res f sp rs c :: s)
+ (Linear.Stackframe (transf_function f) sp ls c' :: s')
+ sig.
+
+Inductive match_states: LTLin.state -> Linear.state -> Prop :=
+ | match_states_intro:
+ forall s f sp c rs m s' ls
+ (STACKS: match_stackframes s s' (LTLin.fn_sig f))
+ (AG: agree rs ls)
+ (WT: wt_function f)
+ (TL: is_tail c (LTLin.fn_code f)),
+ match_states (LTLin.State s f sp c rs m)
+ (Linear.State s' (transf_function f) sp (transf_code f c) ls m)
+ | match_states_call:
+ forall s f rs m s' ls
+ (STACKS: match_stackframes s s' (LTLin.funsig f))
+ (AG: agree_arguments (LTLin.funsig f) rs ls)
+ (WT: wt_fundef f),
+ match_states (LTLin.Callstate s f rs m)
+ (Linear.Callstate s' (transf_fundef f) ls m)
+ | match_states_return:
+ forall s sig rs m s' ls
+ (STACKS: match_stackframes s s' sig)
+ (AG: agree rs ls),
+ match_states (LTLin.Returnstate s sig rs m)
+ (Linear.Returnstate s' ls m).
+
+Remark parent_locset_match:
+ forall s s' sig,
+ match_stackframes s s' sig ->
+ agree (LTLin.parent_locset s) (parent_locset s').
+Proof.
+ induction 1; simpl.
+ red; intros; auto.
+ auto.
+Qed.
+
+Remark match_stackframes_inv:
+ forall s ts sig,
+ match_stackframes s ts sig ->
+ forall sig', sig_res sig' = sig_res sig ->
+ match_stackframes s ts sig'.
+Proof.
+ induction 1; intros.
+ destruct sig'. simpl in H; inv H. constructor.
+ assert (loc_result sig' = loc_result sig).
+ unfold loc_result. rewrite H5; auto.
+ econstructor; eauto. rewrite H6; auto.
+Qed.
+
+Ltac ExploitWT :=
+ match goal with
+ | [ WT: wt_function _, TL: is_tail _ _ |- _ ] =>
+ generalize (wt_instrs _ WT _ (is_tail_in TL)); intro WTI
+ end.
+
+(** The proof of semantic preservation is a simulation argument
+ based on diagrams of the following form:
+<<
+ st1 --------------- st2
+ | |
+ t| *|t
+ | |
+ v v
+ st1'--------------- st2'
+>>
+ It is possible for the transformed code to take no transition,
+ remaining in the same state; for instance, if the source transition
+ corresponds to a move instruction that was eliminated.
+ To ensure that this cannot occur infinitely often in a row,
+ we use the following [measure] function that just counts the
+ remaining number of instructions in the source code sequence. *)
+
+Definition measure (st: LTLin.state) : nat :=
+ match st with
+ | LTLin.State s f sp c ls m => List.length c
+ | LTLin.Callstate s f ls m => 0%nat
+ | LTLin.Returnstate s sig ls m => 0%nat
+ end.
+
+Theorem transf_step_correct:
+ forall s1 t s2, LTLin.step ge s1 t s2 ->
+ forall s1' (MS: match_states s1 s1'),
+ (exists s2', plus Linear.step tge s1' t s2' /\ match_states s2 s2')
+ \/ (measure s2 < measure s1 /\ t = E0 /\ match_states s2 s1')%nat.
+Proof.
+ Opaque regs_for. Opaque add_reloads.
+ induction 1; intros; try inv MS; simpl.
+
+ (* Lop *)
+ ExploitWT. inv WTI.
+ (* move *)
+ simpl.
+ destruct (add_move_correct tge s' (transf_function f) sp r1 res (transf_code f b) ls m)
+ as [ls2 [A [B C]]].
+ inv A.
+ right. split. omega. split. auto.
+ rewrite H1. rewrite H1. econstructor; eauto with coqlib.
+ apply agree_set with ls2; auto.
+ rewrite B. simpl in H; inversion H. auto.
+ left; econstructor; split. eapply plus_left; eauto.
+ econstructor; eauto with coqlib.
+ apply agree_set with ls; auto.
+ rewrite B. simpl in H; inversion H. auto.
+ intros. simpl in H1. apply C. apply Loc.diff_sym; auto.
+ simpl in H7; tauto. simpl in H7; tauto.
+ (* other ops *)
+ assert (is_move_operation op args = None).
+ caseEq (is_move_operation op args); intros.
+ destruct (is_move_operation_correct _ _ H0). congruence.
+ auto.
+ rewrite H0.
+ exploit add_reloads_correct.
+ eapply length_op_args; eauto.
+ apply locs_acceptable_disj_temporaries; auto.
+ intros [ls2 [A [B C]]].
+ exploit add_spill_correct.
+ intros [ls3 [D [E F]]].
+ left; econstructor; split.
+ eapply star_plus_trans. eexact A.
+ eapply plus_left. eapply exec_Lop with (v := v).
+ rewrite <- H. rewrite B. rewrite (agree_locs _ _ _ AG H5).
+ apply eval_operation_preserved. exact symbols_preserved.
+ eexact D. eauto. traceEq.
+ econstructor; eauto with coqlib.
+ apply agree_set with ls; auto.
+ rewrite E. apply Locmap.gss.
+ intros. rewrite F; auto. rewrite Locmap.gso. auto.
+ apply reg_for_diff; auto.
+
+ (* Lload *)
+ ExploitWT; inv WTI.
+ exploit add_reloads_correct.
+ apply le_S. eapply length_addr_args; eauto.
+ apply locs_acceptable_disj_temporaries; auto.
+ intros [ls2 [A [B C]]].
+ exploit add_spill_correct.
+ intros [ls3 [D [E F]]].
+ left; econstructor; split.
+ eapply star_plus_trans. eauto.
+ eapply plus_left. eapply exec_Lload; eauto.
+ rewrite B. rewrite <- H. rewrite (agree_locs _ _ _ AG H7).
+ apply eval_addressing_preserved. exact symbols_preserved.
+ eauto. auto. traceEq.
+ econstructor; eauto with coqlib.
+ apply agree_set with ls; auto.
+ rewrite E. apply Locmap.gss.
+ intros. rewrite F; auto. rewrite Locmap.gso. auto.
+ apply reg_for_diff; auto.
+
+ (* Lstore *)
+ ExploitWT; inv WTI.
+ assert (exists rsrc, exists rargs, regs_for (src :: args) = rsrc :: rargs).
+ Transparent regs_for. unfold regs_for. simpl.
+ destruct src. econstructor; econstructor; eauto.
+ destruct (slot_type s0); econstructor; econstructor; eauto.
+ destruct H1 as [rsrc [rargs EQ]]. rewrite EQ.
+ assert (length (src :: args) <= 3)%nat.
+ simpl. apply le_n_S.
+ eapply length_addr_args; eauto.
+ exploit add_reloads_correct.
+ eauto. apply locs_acceptable_disj_temporaries; auto.
+ red; intros. elim H2; intro; auto. subst l; auto.
+ intros [ls2 [A [B C]]]. rewrite EQ in A. rewrite EQ in B.
+ injection B. intros D E.
+ simpl in B.
+ left; econstructor; split.
+ eapply plus_right. eauto.
+ eapply exec_Lstore with (a := a); eauto.
+ rewrite D. rewrite <- H. rewrite (agree_locs _ _ _ AG H7).
+ apply eval_addressing_preserved. exact symbols_preserved.
+ rewrite E. rewrite (agree_loc _ _ _ AG H8). eauto.
+ traceEq.
+ econstructor; eauto with coqlib.
+ apply agree_exten with ls; auto.
+
+ (* Lcall *)
+ inversion MS. subst s0 f0 sp0 c rs0 m0.
+ simpl transf_code.
+ ExploitWT. inversion WTI. subst sig0 ros0 args0 res0.
+ assert (WTF': wt_fundef f'). eapply find_function_wt; eauto.
+ destruct ros as [fn | id].
+ (* indirect call *)
+ destruct (add_reload_correct tge s' (transf_function f) sp fn IT3
+ (parallel_move args (loc_arguments sig)
+ (Lcall sig (inl ident IT3)
+ :: add_spill (loc_result sig) res (transf_code f b)))
+ ls m)
+ as [ls2 [A [B C]]].
+ destruct (parallel_move_arguments_correct tge s' (transf_function f) sp
+ args sig
+ (Lcall sig (inl ident IT3)
+ :: add_spill (loc_result sig) res (transf_code f b))
+ ls2 m H7 H10)
+ as [ls3 [D [E [F G]]]].
+ assert (AG_ARGS: agree_arguments (LTLin.funsig f') rs1 ls3).
+ rewrite <- H0.
+ unfold rs1. apply agree_set_arguments with ls; auto.
+ rewrite E. apply list_map_exten; intros. symmetry. apply C.
+ assert (Loc.notin x temporaries). apply temporaries_not_acceptable; auto.
+ simpl in H3. apply Loc.diff_sym. tauto.
+ intros. rewrite G; auto. apply C.
+ simpl in H3. apply Loc.diff_sym. tauto.
+ left; econstructor; split.
+ eapply star_plus_trans. eauto. eapply plus_right. eauto.
+ eapply exec_Lcall; eauto.
+ simpl. rewrite F. rewrite B.
+ rewrite (agree_loc rs ls fn); auto.
+ apply functions_translated. eauto.
+ rewrite H0; symmetry; apply sig_preserved.
+ eauto. traceEq.
+ econstructor; eauto.
+ econstructor; eauto with coqlib.
+ rewrite H0. auto.
+ eapply agree_arguments_agree; eauto.
+ (* direct call *)
+ destruct (parallel_move_arguments_correct tge s' (transf_function f) sp
+ args sig
+ (Lcall sig (inr mreg id)
+ :: add_spill (loc_result sig) res (transf_code f b))
+ ls m H7 H10)
+ as [ls3 [D [E [F G]]]].
+ assert (AG_ARGS: agree_arguments (LTLin.funsig f') rs1 ls3).
+ rewrite <- H0.
+ unfold rs1. apply agree_set_arguments with ls; auto.
+ left; econstructor; split.
+ eapply plus_right. eauto.
+ eapply exec_Lcall; eauto.
+ simpl. rewrite symbols_preserved.
+ generalize H; simpl. destruct (Genv.find_symbol ge id).
+ apply function_ptr_translated; auto. congruence.
+ rewrite H0. symmetry; apply sig_preserved.
+ traceEq.
+ econstructor; eauto.
+ econstructor; eauto with coqlib.
+ rewrite H0; auto.
+ eapply agree_arguments_agree; eauto.
+
+ (* Ltailcall *)
+ inversion MS. subst s0 f0 sp c rs0 m0 s1'.
+ simpl transf_code.
+ ExploitWT. inversion WTI. subst sig0 ros0 args0.
+ assert (WTF': wt_fundef f'). eapply find_function_wt; eauto.
+ destruct ros as [fn | id].
+ (* indirect call *)
+ destruct (add_reload_correct tge s' (transf_function f) (Vptr stk Int.zero) fn IT3
+ (parallel_move args (loc_arguments sig)
+ (Ltailcall sig (inl ident IT3) :: transf_code f b))
+ ls m)
+ as [ls2 [A [B C]]].
+ destruct (parallel_move_arguments_correct tge s' (transf_function f) (Vptr stk Int.zero)
+ args sig
+ (Ltailcall sig (inl ident IT3) :: transf_code f b)
+ ls2 m H5 H7)
+ as [ls3 [D [E [F G]]]].
+ assert (AG_ARGS: agree_arguments (LTLin.funsig f') rs2 (LTL.return_regs (parent_locset s') ls3)).
+ rewrite <- H0. unfold rs2.
+ apply agree_arguments_return_regs; auto.
+ eapply parent_locset_match; eauto.
+ unfold rs1. apply agree_set_arguments with ls; auto.
+ rewrite E. apply list_map_exten; intros. symmetry. apply C.
+ assert (Loc.notin x temporaries). apply temporaries_not_acceptable; auto.
+ simpl in H2. apply Loc.diff_sym. tauto.
+ intros. rewrite G; auto. apply C.
+ simpl in H2. apply Loc.diff_sym. tauto.
+ left; econstructor; split.
+ eapply star_plus_trans. eauto. eapply plus_right. eauto.
+ eapply exec_Ltailcall; eauto.
+ simpl. rewrite F. rewrite B.
+ rewrite (agree_loc rs ls fn); auto.
+ apply functions_translated. eauto.
+ rewrite H0; symmetry; apply sig_preserved.
+ eauto. traceEq.
+ econstructor; eauto.
+ eapply match_stackframes_inv; eauto. congruence.
+
+ (* direct call *)
+ destruct (parallel_move_arguments_correct tge s' (transf_function f) (Vptr stk Int.zero)
+ args sig
+ (Ltailcall sig (inr mreg id) :: transf_code f b)
+ ls m H5 H7)
+ as [ls3 [D [E [F G]]]].
+ assert (AG_ARGS: agree_arguments (LTLin.funsig f') rs2 (LTL.return_regs (parent_locset s') ls3)).
+ rewrite <- H0. unfold rs2.
+ apply agree_arguments_return_regs; auto.
+ eapply parent_locset_match; eauto.
+ unfold rs1. apply agree_set_arguments with ls; auto.
+ left; econstructor; split.
+ eapply plus_right. eauto.
+ eapply exec_Ltailcall; eauto.
+ simpl. rewrite symbols_preserved.
+ generalize H; simpl. destruct (Genv.find_symbol ge id).
+ apply function_ptr_translated; auto. congruence.
+ rewrite H0. symmetry; apply sig_preserved.
+ traceEq.
+ econstructor; eauto.
+ eapply match_stackframes_inv; eauto. congruence.
+
+ (* Lalloc *)
+ ExploitWT; inv WTI.
+ exploit add_reload_correct. intros [ls2 [A [B C]]].
+ exploit add_spill_correct. intros [ls3 [D [E F]]].
+ left; econstructor; split.
+ eapply star_plus_trans. eauto.
+ eapply plus_left. eapply exec_Lalloc; eauto.
+ rewrite B. rewrite <- H. apply AG. auto.
+ eauto. eauto. traceEq.
+ econstructor; eauto with coqlib.
+ unfold rs3; apply agree_set with (Locmap.set (R loc_alloc_result) (Vptr blk Int.zero) ls2).
+ auto. rewrite E. rewrite Locmap.gss.
+ unfold rs2; rewrite Locmap.gss. auto.
+ auto.
+ unfold rs2. apply agree_set with ls2.
+ unfold loc_alloc_result; simpl; intuition congruence.
+ apply Locmap.gss. intros. apply Locmap.gso; auto.
+ unfold rs1. apply agree_set with ls.
+ unfold loc_alloc_argument; simpl; intuition congruence.
+ rewrite B. apply AG; auto. auto. auto.
+
+ (* Llabel *)
+ left; econstructor; split.
+ apply plus_one. apply exec_Llabel.
+ econstructor; eauto with coqlib.
+
+ (* Lgoto *)
+ left; econstructor; split.
+ apply plus_one. apply exec_Lgoto. apply find_label_transf_function; eauto.
+ econstructor; eauto.
+ eapply LTLin.find_label_is_tail; eauto.
+
+ (* Lcond true *)
+ ExploitWT; inv WTI.
+ exploit add_reloads_correct.
+ eapply length_cond_args; eauto.
+ apply locs_acceptable_disj_temporaries; auto.
+ intros [ls2 [A [B C]]].
+ left; econstructor; split.
+ eapply plus_right. eauto. eapply exec_Lcond_true; eauto.
+ rewrite B. rewrite (agree_locs _ _ _ AG H5). auto.
+ apply find_label_transf_function; eauto.
+ traceEq.
+ econstructor; eauto.
+ apply agree_exten with ls; auto.
+ eapply LTLin.find_label_is_tail; eauto.
+
+ (* Lcond false *)
+ ExploitWT; inv WTI.
+ exploit add_reloads_correct.
+ eapply length_cond_args; eauto.
+ apply locs_acceptable_disj_temporaries; auto.
+ intros [ls2 [A [B C]]].
+ left; econstructor; split.
+ eapply plus_right. eauto. eapply exec_Lcond_false; eauto.
+ rewrite B. rewrite (agree_locs _ _ _ AG H4). auto.
+ traceEq.
+ econstructor; eauto with coqlib.
+ apply agree_exten with ls; auto.
+
+ (* Lreturn *)
+ ExploitWT; inv WTI.
+ unfold rs2, rs1; destruct or; simpl.
+ (* with an argument *)
+ exploit add_reload_correct.
+ intros [ls2 [A [B C]]].
+ left; econstructor; split.
+ eapply plus_right. eauto. eapply exec_Lreturn; eauto.
+ traceEq.
+ econstructor; eauto.
+ apply agree_return_regs; auto.
+ eapply parent_locset_match; eauto.
+ apply agree_set with ls.
+ apply loc_result_acceptable.
+ rewrite B. eapply agree_loc; eauto.
+ auto. auto.
+ (* without an argument *)
+ left; econstructor; split.
+ apply plus_one. eapply exec_Lreturn; eauto.
+ econstructor; eauto.
+ apply agree_return_regs; auto.
+ eapply parent_locset_match; eauto.
+
+ (* internal function *)
+ simpl in WT. inversion_clear WT. inversion H0. simpl in AG.
+ destruct (parallel_move_parameters_correct tge s' (transf_function f)
+ (Vptr stk Int.zero) (LTLin.fn_params f) (LTLin.fn_sig f)
+ (transf_code f (LTLin.fn_code f)) (LTL.call_regs ls) m'
+ wt_params wt_acceptable wt_norepet)
+ as [ls2 [A [B [C D]]]].
+ assert (AG2: agree rs2 ls2).
+ unfold rs2. eapply agree_set_parameters; eauto.
+ unfold rs1. apply agree_call_regs; auto.
+ left; econstructor; split.
+ eapply plus_left.
+ eapply exec_function_internal; eauto.
+ simpl. eauto. traceEq.
+ econstructor; eauto with coqlib.
+
+ (* external function *)
+ left; econstructor; split.
+ apply plus_one. eapply exec_function_external; eauto.
+ unfold args. symmetry. eapply agree_arguments_locs; auto.
+ econstructor; eauto.
+ unfold rs1. apply agree_set with ls; auto.
+ apply loc_result_acceptable.
+ apply Locmap.gss.
+ intros. apply Locmap.gso; auto.
+ eapply agree_arguments_agree; eauto.
+
+ (* return *)
+ inv STACKS.
+ exploit add_spill_correct. intros [ls2 [A [B C]]].
+ left; econstructor; split.
+ eapply plus_left. eapply exec_return; eauto.
+ eauto. traceEq.
+ econstructor; eauto.
+ unfold rs1. apply agree_set with ls; auto.
+ rewrite B. apply AG. apply loc_result_acceptable.
+Qed.
+
+Lemma transf_initial_states:
+ forall st1, LTLin.initial_state prog st1 ->
+ exists st2, Linear.initial_state tprog st2 /\ match_states st1 st2.
+Proof.
+ intros. inversion H.
+ econstructor; split.
+ econstructor.
+ change (prog_main tprog) with (prog_main prog).
+ rewrite symbols_preserved. eauto.
+ apply function_ptr_translated; eauto.
+ rewrite sig_preserved. auto.
+ replace (Genv.init_mem tprog) with (Genv.init_mem prog).
+ econstructor; eauto. rewrite H2. constructor.
+ red; intros. auto.
+ eapply Genv.find_funct_ptr_prop; eauto.
+ symmetry. unfold tprog, transf_program. apply Genv.init_mem_transf; auto.
+Qed.
+
+Lemma transf_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 -> LTLin.final_state st1 r -> Linear.final_state st2 r.
+Proof.
+ intros. inv H0. inv H. inv STACKS. econstructor.
+ rewrite (agree_loc _ _ (R R3) AG). auto.
+ simpl. intuition congruence.
+Qed.
+
+Theorem transf_program_correct:
+ forall (beh: program_behavior),
+ LTLin.exec_program prog beh -> Linear.exec_program tprog beh.
+Proof.
+ unfold LTLin.exec_program, Linear.exec_program; intros.
+ eapply simulation_star_preservation; eauto.
+ eexact transf_initial_states.
+ eexact transf_final_states.
+ eexact transf_step_correct.
+Qed.
+
+End PRESERVATION.
diff --git a/backend/Reloadtyping.v b/backend/Reloadtyping.v
new file mode 100644
index 0000000000000000000000000000000000000000..155c174d57851c90eca53cb2562a4c66091e5b46
--- /dev/null
+++ b/backend/Reloadtyping.v
@@ -0,0 +1,309 @@
+(** Proof of type preservation for Reload and of
+ correctness of computation of stack bounds for Linear. *)
+
+Require Import Coqlib.
+Require Import Maps.
+Require Import AST.
+Require Import Op.
+Require Import Locations.
+Require Import LTLin.
+Require Import LTLintyping.
+Require Import Linear.
+Require Import Lineartyping.
+Require Import Conventions.
+Require Import Parallelmove.
+Require Import Reload.
+Require Import Reloadproof.
+
+(** * Typing Linear constructors *)
+
+(** We show that the Linear constructor functions defined in [Reload]
+ generate well-typed instruction sequences,
+ given sufficient typing and well-formedness hypotheses over the locations involved. *)
+
+Hint Resolve wt_Lgetstack wt_Lsetstack wt_Lopmove
+ wt_Lop wt_Lload wt_Lstore wt_Lcall wt_Ltailcall wt_Lalloc
+ wt_Llabel wt_Lgoto wt_Lcond wt_Lreturn: reloadty.
+
+Remark wt_code_cons:
+ forall f i c, wt_instr f i -> wt_code f c -> wt_code f (i :: c).
+Proof.
+ intros; red; simpl; intros. elim H1; intro.
+ subst i; auto. auto.
+Qed.
+
+Hint Resolve wt_code_cons: reloadty.
+
+Definition loc_valid (f: function) (l: loc) :=
+ match l with R _ => True | S s => slot_valid f s end.
+
+Lemma loc_acceptable_valid:
+ forall f l, loc_acceptable l -> loc_valid f l.
+Proof.
+ destruct l; simpl; intro. auto.
+ destruct s; simpl. omega. tauto. tauto.
+Qed.
+
+Definition loc_writable (l: loc) :=
+ match l with R _ => True | S s => slot_writable s end.
+
+Lemma loc_acceptable_writable:
+ forall l, loc_acceptable l -> loc_writable l.
+Proof.
+ destruct l; simpl; intro. auto.
+ destruct s; simpl; tauto.
+Qed.
+
+Hint Resolve loc_acceptable_valid loc_acceptable_writable: reloadty.
+
+Definition locs_valid (f: function) (ll: list loc) :=
+ forall l, In l ll -> loc_valid f l.
+Definition locs_writable (ll: list loc) :=
+ forall l, In l ll -> loc_writable l.
+
+Lemma locs_acceptable_valid:
+ forall f ll, locs_acceptable ll -> locs_valid f ll.
+Proof.
+ unfold locs_acceptable, locs_valid. auto with reloadty.
+Qed.
+
+Lemma locs_acceptable_writable:
+ forall ll, locs_acceptable ll -> locs_writable ll.
+Proof.
+ unfold locs_acceptable, locs_writable. auto with reloadty.
+Qed.
+
+Hint Resolve locs_acceptable_valid locs_acceptable_writable: reloadty.
+
+Lemma wt_add_reload:
+ forall f src dst k,
+ loc_valid f src -> Loc.type src = mreg_type dst ->
+ wt_code f k -> wt_code f (add_reload src dst k).
+Proof.
+ intros; unfold add_reload.
+ destruct src; eauto with reloadty.
+ destruct (mreg_eq m dst); eauto with reloadty.
+Qed.
+
+Hint Resolve wt_add_reload: reloadty.
+
+Lemma wt_add_reloads:
+ forall f srcs dsts k,
+ locs_valid f srcs -> map Loc.type srcs = map mreg_type dsts ->
+ wt_code f k -> wt_code f (add_reloads srcs dsts k).
+Proof.
+ induction srcs; destruct dsts; simpl; intros; try congruence.
+ auto. inv H0. apply wt_add_reload; auto with coqlib reloadty.
+ apply IHsrcs; auto. red; intros; auto with coqlib.
+Qed.
+
+Hint Resolve wt_add_reloads: reloadty.
+
+Lemma wt_add_spill:
+ forall f src dst k,
+ loc_valid f dst -> loc_writable dst -> Loc.type dst = mreg_type src ->
+ wt_code f k -> wt_code f (add_spill src dst k).
+Proof.
+ intros; unfold add_spill.
+ destruct dst; eauto with reloadty.
+ destruct (mreg_eq src m); eauto with reloadty.
+Qed.
+
+Hint Resolve wt_add_spill: reloadty.
+
+Lemma wt_add_move:
+ forall f src dst k,
+ loc_valid f src -> loc_valid f dst -> loc_writable dst ->
+ Loc.type dst = Loc.type src ->
+ wt_code f k -> wt_code f (add_move src dst k).
+Proof.
+ intros. unfold add_move.
+ destruct (Loc.eq src dst); auto.
+ destruct src; auto with reloadty.
+ destruct dst; auto with reloadty.
+ set (tmp := match slot_type s with
+ | Tint => IT1
+ | Tfloat => FT1
+ end).
+ assert (mreg_type tmp = Loc.type (S s)).
+ simpl. destruct (slot_type s); reflexivity.
+ apply wt_add_reload; auto with reloadty.
+ apply wt_add_spill; auto. congruence.
+Qed.
+
+Hint Resolve wt_add_move: reloadty.
+
+Lemma wt_add_moves:
+ forall f b moves,
+ (forall s d, In (s, d) moves ->
+ loc_valid f s /\ loc_valid f d /\ loc_writable d /\ Loc.type s = Loc.type d) ->
+ wt_code f b ->
+ wt_code f
+ (List.fold_right (fun p k => add_move (fst p) (snd p) k) b moves).
+Proof.
+ induction moves; simpl; intros.
+ auto.
+ destruct a as [s d]. simpl.
+ destruct (H s d) as [A [B [C D]]]. auto.
+ auto with reloadty.
+Qed.
+
+Theorem wt_parallel_move:
+ forall f srcs dsts b,
+ List.map Loc.type srcs = List.map Loc.type dsts ->
+ locs_valid f srcs -> locs_valid f dsts -> locs_writable dsts ->
+ wt_code f b -> wt_code f (parallel_move srcs dsts b).
+Proof.
+ intros. unfold parallel_move. apply wt_add_moves; auto.
+ intros.
+ elim (parmove_prop_2 _ _ _ _ H4); intros A B.
+ split. destruct A as [C|[C|C]]; auto; subst s; exact I.
+ split. destruct B as [C|[C|C]]; auto; subst d; exact I.
+ split. destruct B as [C|[C|C]]; auto; subst d; exact I.
+ eapply parmove_prop_3; eauto.
+Qed.
+Hint Resolve wt_parallel_move: reloadty.
+
+Lemma wt_reg_for:
+ forall l, mreg_type (reg_for l) = Loc.type l.
+Proof.
+ intros. destruct l; simpl. auto.
+ case (slot_type s); reflexivity.
+Qed.
+Hint Resolve wt_reg_for: reloadty.
+
+Lemma wt_regs_for_rec:
+ forall locs itmps ftmps,
+ (List.length locs <= List.length itmps)%nat ->
+ (List.length locs <= List.length ftmps)%nat ->
+ (forall r, In r itmps -> mreg_type r = Tint) ->
+ (forall r, In r ftmps -> mreg_type r = Tfloat) ->
+ List.map mreg_type (regs_for_rec locs itmps ftmps) = List.map Loc.type locs.
+Proof.
+ induction locs; intros.
+ simpl. auto.
+ destruct itmps; simpl in H. omegaContradiction.
+ destruct ftmps; simpl in H0. omegaContradiction.
+ simpl. apply (f_equal2 (@cons typ)).
+ destruct a. reflexivity. simpl. case (slot_type s).
+ apply H1; apply in_eq. apply H2; apply in_eq.
+ apply IHlocs. omega. omega.
+ intros; apply H1; apply in_cons; auto.
+ intros; apply H2; apply in_cons; auto.
+Qed.
+
+Lemma wt_regs_for:
+ forall locs,
+ (List.length locs <= 3)%nat ->
+ List.map mreg_type (regs_for locs) = List.map Loc.type locs.
+Proof.
+ intros. unfold regs_for. apply wt_regs_for_rec.
+ simpl. auto. simpl. auto.
+ simpl; intros; intuition; subst r; reflexivity.
+ simpl; intros; intuition; subst r; reflexivity.
+Qed.
+Hint Resolve wt_regs_for: reloadty.
+
+Hint Resolve length_op_args length_addr_args length_cond_args: reloadty.
+
+Hint Extern 4 (_ = _) => congruence : reloadty.
+
+Lemma wt_transf_instr:
+ forall f instr k,
+ LTLintyping.wt_instr (LTLin.fn_sig f) instr ->
+ wt_code (transf_function f) k ->
+ wt_code (transf_function f) (transf_instr f instr k).
+Proof.
+ Opaque reg_for regs_for.
+ intros. inv H; simpl; auto with reloadty.
+ caseEq (is_move_operation op args); intros.
+ destruct (is_move_operation_correct _ _ H). congruence.
+ assert (map mreg_type (regs_for args) = map Loc.type args).
+ eauto with reloadty.
+ assert (mreg_type (reg_for res) = Loc.type res). eauto with reloadty.
+ auto with reloadty.
+
+ assert (map mreg_type (regs_for args) = map Loc.type args).
+ eauto with reloadty.
+ assert (mreg_type (reg_for dst) = Loc.type dst). eauto with reloadty.
+ auto with reloadty.
+
+ caseEq (regs_for (src :: args)); intros.
+ red; simpl; tauto.
+ assert (map mreg_type (regs_for (src :: args)) = map Loc.type (src :: args)).
+ apply wt_regs_for. simpl. apply le_n_S. eauto with reloadty.
+ rewrite H in H5. injection H5; intros.
+ auto with reloadty.
+
+ assert (locs_valid (transf_function f) (loc_arguments sig)).
+ red; intros. generalize (loc_arguments_acceptable sig l H).
+ destruct l; simpl; auto. destruct s; simpl; intuition.
+ assert (locs_writable (loc_arguments sig)).
+ red; intros. generalize (loc_arguments_acceptable sig l H7).
+ destruct l; simpl; auto. destruct s; simpl; intuition.
+ assert (map Loc.type args = map Loc.type (loc_arguments sig)).
+ rewrite loc_arguments_type; auto.
+ assert (Loc.type res = mreg_type (loc_result sig)).
+ rewrite H3. unfold loc_result.
+ destruct (sig_res sig); auto. destruct t; auto.
+ destruct ros; auto 10 with reloadty.
+
+ assert (locs_valid (transf_function f) (loc_arguments sig)).
+ red; intros. generalize (loc_arguments_acceptable sig l H).
+ destruct l; simpl; auto. destruct s; simpl; intuition.
+ assert (locs_writable (loc_arguments sig)).
+ red; intros. generalize (loc_arguments_acceptable sig l H7).
+ destruct l; simpl; auto. destruct s; simpl; intuition.
+ assert (map Loc.type args = map Loc.type (loc_arguments sig)).
+ rewrite loc_arguments_type; auto.
+ destruct ros; auto 10 with reloadty.
+
+ assert (map mreg_type (regs_for args) = map Loc.type args).
+ eauto with reloadty.
+ auto with reloadty.
+
+ destruct optres; simpl in *; auto with reloadty.
+ apply wt_add_reload; auto with reloadty.
+ unfold loc_result. rewrite <- H1.
+ destruct (Loc.type l); reflexivity.
+Qed.
+
+Lemma wt_transf_code:
+ forall f c,
+ LTLintyping.wt_code (LTLin.fn_sig f) c ->
+ Lineartyping.wt_code (transf_function f) (transf_code f c).
+Proof.
+ induction c; simpl; intros.
+ red; simpl; tauto.
+ apply wt_transf_instr; auto with coqlib.
+ apply IHc. red; auto with coqlib.
+Qed.
+
+Lemma wt_transf_fundef:
+ forall fd,
+ LTLintyping.wt_fundef fd ->
+ Lineartyping.wt_fundef (transf_fundef fd).
+Proof.
+ intros. destruct fd; simpl.
+ inv H. inv H1. constructor. unfold wt_function. simpl.
+ apply wt_parallel_move; auto with reloadty.
+ rewrite loc_parameters_type. auto.
+ unfold loc_parameters; red; intros.
+ destruct (list_in_map_inv _ _ _ H) as [r [A B]]. rewrite A.
+ generalize (loc_arguments_acceptable _ _ B).
+ destruct r; simpl; auto. destruct s; try tauto.
+ intros; simpl. split. omega.
+ apply loc_arguments_bounded; auto.
+ apply wt_transf_code; auto.
+ constructor.
+Qed.
+
+Lemma program_typing_preserved:
+ forall p,
+ LTLintyping.wt_program p ->
+ Lineartyping.wt_program (transf_program p).
+Proof.
+ intros; red; intros.
+ destruct (transform_program_function _ _ _ _ H0) as [f0 [A B]].
+ subst f; apply wt_transf_fundef. eauto.
+Qed.
diff --git a/backend/Cmconstr.v b/backend/Selection.v
similarity index 82%
rename from backend/Cmconstr.v
rename to backend/Selection.v
index 2cc947c78b13da88f47c575fa6db090b04d6ccc4..c98e55e4f1ce131892b889a318fc0b393ce55ea2 100644
--- a/backend/Cmconstr.v
+++ b/backend/Selection.v
@@ -1,47 +1,37 @@
-(** Smart constructors for Cminor. This library provides functions
- for building Cminor expressions and statements, especially expressions
- consisting of operator applications. These functions examine their
- arguments to choose cheaper forms of operators whenever possible.
+(** Instruction selection *)
- For instance, [add e1 e2] will return a Cminor expression semantically
- equivalent to [Eop Oadd (e1 ::: e2 ::: Enil)], but will use a
- [Oaddimm] operator if one of the arguments is an integer constant,
- or suppress the addition altogether if one of the arguments is the
- null integer. In passing, we perform operator reassociation
- ([(e + c1) * c2] becomes [(e * c2) + (c1 * c2)]) and a small amount
- of constant propagation.
+(** The instruction selection pass recognizes opportunities for using
+ combined arithmetic and logical operations and addressing modes
+ offered by the target processor. For instance, the expression [x + 1]
+ can take advantage of the "immediate add" instruction of the processor,
+ and on the PowerPC, the expression [(x >> 6) & 0xFF] can be turned
+ into a "rotate and mask" instruction.
- In more general terms, the purpose of the smart constructors is twofold:
-- Perform instruction selection (for operators, loads, stores and
- conditional expressions);
-- Abstract over processor dependencies in operators and addressing modes,
- providing Cminor providers with processor-independent ways of constructing
- Cminor terms.
-*)
+ Instruction selection proceeds by bottom-up rewriting over expressions.
+ The source language is Cminor and the target language is CminorSel. *)
Require Import Coqlib.
-Require Import Compare_dec.
Require Import Maps.
Require Import AST.
Require Import Integers.
Require Import Floats.
Require Import Values.
Require Import Mem.
-Require Import Op.
Require Import Globalenvs.
-Require Import Cminor.
+Require Cminor.
+Require Import Op.
+Require Import CminorSel.
-Infix ":::" := Econs (at level 60, right associativity) : cminor_scope.
+Infix ":::" := Econs (at level 60, right associativity) : selection_scope.
-Open Scope cminor_scope.
+Open Local Scope selection_scope.
(** * Lifting of let-bound variables *)
-(** Some of the smart constructors, as well as the Cminor producers,
- generate [Elet] constructs to share the evaluation of a subexpression.
- Owing to the use of de Bruijn indices for let-bound variables,
- we need to shift de Bruijn indices when an expression [b] is put
- in a [Elet a b] context. *)
+(** Some of the instruction functions generate [Elet] constructs to
+ share the evaluation of a subexpression. Owing to the use of de
+ Bruijn indices for let-bound variables, we need to shift de Bruijn
+ indices when an expression [b] is put in a [Elet a b] context. *)
Fixpoint lift_expr (p: nat) (a: expr) {struct a}: expr :=
match a with
@@ -79,12 +69,19 @@ Definition lift (a: expr): expr := lift_expr O a.
(** * Smart constructors for operators *)
-Definition negint (e: expr) := Eop (Osubimm Int.zero) (e ::: Enil).
-Definition negfloat (e: expr) := Eop Onegf (e ::: Enil).
-Definition absfloat (e: expr) := Eop Oabsf (e ::: Enil).
-Definition intoffloat (e: expr) := Eop Ointoffloat (e ::: Enil).
-Definition floatofint (e: expr) := Eop Ofloatofint (e ::: Enil).
-Definition floatofintu (e: expr) := Eop Ofloatofintu (e ::: Enil).
+(** This section defines functions for building CminorSel expressions
+ and statements, especially expressions consisting of operator
+ applications. These functions examine their arguments to choose
+ cheaper forms of operators whenever possible.
+
+ For instance, [add e1 e2] will return a CminorSel expression semantically
+ equivalent to [Eop Oadd (e1 ::: e2 ::: Enil)], but will use a
+ [Oaddimm] operator if one of the arguments is an integer constant,
+ or suppress the addition altogether if one of the arguments is the
+ null integer. In passing, we perform operator reassociation
+ ([(e + c1) * c2] becomes [(e * c2) + (c1 * c2)]) and a small amount
+ of constant propagation.
+*)
(** ** Integer logical negation *)
@@ -129,7 +126,7 @@ Inductive notint_cases: forall (e: expr), Set :=
notint_cases e.
(** We then define a classification function that takes an expression
- and return in which case it falls. Note that the catch-all case
+ and return the case in which it falls. Note that the catch-all case
[notint_default] does not state that it is mutually exclusive with
the first three, more specific cases. The classification function
nonetheless chooses the specific cases in preference to the catch-all
@@ -174,7 +171,7 @@ Definition notint (e: expr) :=
(** ** Boolean negation *)
Definition notbool_base (e: expr) :=
- Eop (Ocmp (Ccompuimm Ceq Int.zero)) (e ::: Enil).
+ Eop (Ocmp (Ccompimm Ceq Int.zero)) (e ::: Enil).
Fixpoint notbool (e: expr) {struct e} : expr :=
match e with
@@ -672,8 +669,6 @@ Definition or (e1: expr) (e2: expr) :=
Eop Oor (e1:::e2:::Enil)
end.
-Definition xor (e1 e2: expr) := Eop Oxor (e1:::e2:::Enil).
-
(** ** General shifts *)
Inductive shift_cases: forall (e1: expr), Set :=
@@ -700,9 +695,6 @@ Definition shl (e1: expr) (e2: expr) :=
Eop Oshl (e1:::e2:::Enil)
end.
-Definition shr (e1 e2: expr) :=
- Eop Oshr (e1:::e2:::Enil).
-
Definition shru (e1: expr) (e2: expr) :=
match shift_match e2 with
| shift_case1 n2 =>
@@ -791,9 +783,6 @@ Definition subf (e1: expr) (e2: expr) :=
Eop Osubf (e1:::e2:::Enil)
end.
-Definition mulf (e1 e2: expr) := Eop Omulf (e1:::e2:::Enil).
-Definition divf (e1 e2: expr) := Eop Odivf (e1:::e2:::Enil).
-
(** ** Truncations and sign extensions *)
Inductive cast8signed_cases: forall (e1: expr), Set :=
@@ -906,14 +895,7 @@ Definition singleoffloat (e: expr) :=
| singleoffloat_default e1 => Eop Osingleoffloat (e1 ::: Enil)
end.
-(** ** Comparisons and conditional expressions *)
-
-Definition cmp (c: comparison) (e1 e2: expr) :=
- Eop (Ocmp (Ccomp c)) (e1:::e2:::Enil).
-Definition cmpu (c: comparison) (e1 e2: expr) :=
- Eop (Ocmp (Ccompu c)) (e1:::e2:::Enil).
-Definition cmpf (c: comparison) (e1 e2: expr) :=
- Eop (Ocmp (Ccompf c)) (e1:::e2:::Enil).
+(** ** Conditional expressions *)
Fixpoint condexpr_of_expr (e: expr) : condexpr :=
match e with
@@ -922,12 +904,9 @@ Fixpoint condexpr_of_expr (e: expr) : condexpr :=
| Eop (Ocmp c) el => CEcond c el
| Econdition e1 e2 e3 =>
CEcondition e1 (condexpr_of_expr e2) (condexpr_of_expr e3)
- | e => CEcond (Ccompuimm Cne Int.zero) (e:::Enil)
+ | e => CEcond (Ccompimm Cne Int.zero) (e:::Enil)
end.
-Definition conditionalexpr (e1 e2 e3: expr) : expr :=
- Econdition (condexpr_of_expr e1) e2 e3.
-
(** ** Recognition of addressing modes for load and store operations *)
(*
@@ -1005,7 +984,120 @@ Definition store (chunk: memory_chunk) (e1 e2: expr) :=
| (mode, args) => Estore chunk mode args e2
end.
-(** ** If-then-else statement *)
+(** * Translation from Cminor to CminorSel *)
+
+(** Instruction selection for operator applications *)
+
+Definition sel_constant (cst: Cminor.constant) : expr :=
+ match cst with
+ | Cminor.Ointconst n => Eop (Ointconst n) Enil
+ | Cminor.Ofloatconst f => Eop (Ofloatconst f) Enil
+ | Cminor.Oaddrsymbol id ofs => Eop (Oaddrsymbol id ofs) Enil
+ | Cminor.Oaddrstack ofs => Eop (Oaddrstack ofs) Enil
+ end.
+
+Definition sel_unop (op: Cminor.unary_operation) (arg: expr) : expr :=
+ match op with
+ | Cminor.Ocast8unsigned => cast8unsigned arg
+ | Cminor.Ocast8signed => cast8signed arg
+ | Cminor.Ocast16unsigned => cast16unsigned arg
+ | Cminor.Ocast16signed => cast16signed arg
+ | Cminor.Onegint => Eop (Osubimm Int.zero) (arg ::: Enil)
+ | Cminor.Onotbool => notbool arg
+ | Cminor.Onotint => notint arg
+ | Cminor.Onegf => Eop Onegf (arg ::: Enil)
+ | Cminor.Oabsf => Eop Oabsf (arg ::: Enil)
+ | Cminor.Osingleoffloat => singleoffloat arg
+ | Cminor.Ointoffloat => Eop Ointoffloat (arg ::: Enil)
+ | Cminor.Ofloatofint => Eop Ofloatofint (arg ::: Enil)
+ | Cminor.Ofloatofintu => Eop Ofloatofintu (arg ::: Enil)
+ end.
+
+Definition sel_binop (op: Cminor.binary_operation) (arg1 arg2: expr) : expr :=
+ match op with
+ | Cminor.Oadd => add arg1 arg2
+ | Cminor.Osub => sub arg1 arg2
+ | Cminor.Omul => mul arg1 arg2
+ | Cminor.Odiv => divs arg1 arg2
+ | Cminor.Odivu => divu arg1 arg2
+ | Cminor.Omod => mods arg1 arg2
+ | Cminor.Omodu => modu arg1 arg2
+ | Cminor.Oand => and arg1 arg2
+ | Cminor.Oor => or arg1 arg2
+ | Cminor.Oxor => Eop Oxor (arg1 ::: arg2 ::: Enil)
+ | Cminor.Oshl => shl arg1 arg2
+ | Cminor.Oshr => Eop Oshr (arg1 ::: arg2 ::: Enil)
+ | Cminor.Oshru => shru arg1 arg2
+ | Cminor.Oaddf => addf arg1 arg2
+ | Cminor.Osubf => subf arg1 arg2
+ | Cminor.Omulf => Eop Omulf (arg1 ::: arg2 ::: Enil)
+ | Cminor.Odivf => Eop Odivf (arg1 ::: arg2 ::: Enil)
+ | Cminor.Ocmp c => Eop (Ocmp (Ccomp c)) (arg1 ::: arg2 ::: Enil)
+ | Cminor.Ocmpu c => Eop (Ocmp (Ccompu c)) (arg1 ::: arg2 ::: Enil)
+ | Cminor.Ocmpf c => Eop (Ocmp (Ccompf c)) (arg1 ::: arg2 ::: Enil)
+ end.
+
+(** Conversion from Cminor expression to Cminorsel expressions *)
+
+Fixpoint sel_expr (a: Cminor.expr) : expr :=
+ match a with
+ | Cminor.Evar id => Evar id
+ | Cminor.Econst cst => sel_constant cst
+ | Cminor.Eunop op arg => sel_unop op (sel_expr arg)
+ | Cminor.Ebinop op arg1 arg2 => sel_binop op (sel_expr arg1) (sel_expr arg2)
+ | Cminor.Eload chunk addr => load chunk (sel_expr addr)
+ | Cminor.Estore chunk addr rhs => store chunk (sel_expr addr) (sel_expr rhs)
+ | Cminor.Ecall sg fn args => Ecall sg (sel_expr fn) (sel_exprlist args)
+ | Cminor.Econdition cond ifso ifnot =>
+ Econdition (condexpr_of_expr (sel_expr cond))
+ (sel_expr ifso) (sel_expr ifnot)
+ | Cminor.Elet b c => Elet (sel_expr b) (sel_expr c)
+ | Cminor.Eletvar n => Eletvar n
+ | Cminor.Ealloc b => Ealloc (sel_expr b)
+ end
+
+with sel_exprlist (al: Cminor.exprlist) : exprlist :=
+ match al with
+ | Cminor.Enil => Enil
+ | Cminor.Econs a bl => Econs (sel_expr a) (sel_exprlist bl)
+ end.
+
+(** Conversion from Cminor statements to Cminorsel statements. *)
+
+Fixpoint sel_stmt (s: Cminor.stmt) : stmt :=
+ match s with
+ | Cminor.Sskip => Sskip
+ | Cminor.Sexpr e => Sexpr (sel_expr e)
+ | Cminor.Sassign id e => Sassign id (sel_expr e)
+ | Cminor.Sseq s1 s2 => Sseq (sel_stmt s1) (sel_stmt s2)
+ | Cminor.Sifthenelse e ifso ifnot =>
+ Sifthenelse (condexpr_of_expr (sel_expr e))
+ (sel_stmt ifso) (sel_stmt ifnot)
+ | Cminor.Sloop body => Sloop (sel_stmt body)
+ | Cminor.Sblock body => Sblock (sel_stmt body)
+ | Cminor.Sexit n => Sexit n
+ | Cminor.Sswitch e cases dfl => Sswitch (sel_expr e) cases dfl
+ | Cminor.Sreturn None => Sreturn None
+ | Cminor.Sreturn (Some e) => Sreturn (Some (sel_expr e))
+ | Cminor.Stailcall sg fn args =>
+ Stailcall sg (sel_expr fn) (sel_exprlist args)
+ end.
+
+(** Conversion of functions and programs. *)
+
+Definition sel_function (f: Cminor.function) : function :=
+ mkfunction
+ f.(Cminor.fn_sig)
+ f.(Cminor.fn_params)
+ f.(Cminor.fn_vars)
+ f.(Cminor.fn_stackspace)
+ (sel_stmt f.(Cminor.fn_body)).
+
+Definition sel_fundef (f: Cminor.fundef) : fundef :=
+ transf_fundef sel_function f.
+
+Definition sel_program (p: Cminor.program) : program :=
+ transform_program sel_fundef p.
+
+
-Definition ifthenelse (e: expr) (ifso ifnot: stmt) : stmt :=
- Sifthenelse (condexpr_of_expr e) ifso ifnot.
diff --git a/backend/Cmconstrproof.v b/backend/Selectionproof.v
similarity index 79%
rename from backend/Cmconstrproof.v
rename to backend/Selectionproof.v
index 35b3d8a0315be15b8881d3865a6de1044b3a17ec..e41765a76f968e4f023ca5adcb8482254318ca15 100644
--- a/backend/Cmconstrproof.v
+++ b/backend/Selectionproof.v
@@ -1,15 +1,6 @@
-(** Correctness of the Cminor smart constructors. This file states
- evaluation rules for the smart constructors, for instance that [add
- a b] evaluates to [Vint(Int.add i j)] if [a] evaluates to [Vint i]
- and [b] to [Vint j]. It then proves that these rules are
- admissible, that is, satisfied for all possible choices of [a] and
- [b]. The Cminor producer can then use these evaluation rules
- (theorems) to reason about the execution of terms produced by the
- smart constructors.
-*)
+(** Correctness of instruction selection *)
Require Import Coqlib.
-Require Import Compare_dec.
Require Import Maps.
Require Import AST.
Require Import Integers.
@@ -17,14 +8,17 @@ Require Import Floats.
Require Import Values.
Require Import Mem.
Require Import Events.
-Require Import Op.
Require Import Globalenvs.
Require Import Cminor.
-Require Import Cmconstr.
+Require Import Op.
+Require Import CminorSel.
+Require Import Selection.
+
+Open Local Scope selection_scope.
Section CMCONSTR.
-Variable ge: Cminor.genv.
+Variable ge: genv.
(** * Lifting of let-bound variables *)
@@ -150,19 +144,18 @@ Hint Resolve eval_lift: evalexpr.
(** * Useful lemmas and tactics *)
-Ltac EvalOp := eapply eval_Eop; eauto with evalexpr.
-
-Ltac TrivialOp cstr :=
- unfold cstr; intros; EvalOp.
-
(** The following are trivial lemmas and custom tactics that help
perform backward (inversion) and forward reasoning over the evaluation
of operator applications. *)
+Ltac EvalOp := eapply eval_Eop; eauto with evalexpr.
+
+Ltac TrivialOp cstr := unfold cstr; intros; EvalOp.
+
Lemma inv_eval_Eop_0:
forall sp le e m1 op t m2 v,
eval_expr ge sp le e m1 (Eop op Enil) t m2 v ->
- t = E0 /\ m2 = m1 /\ eval_operation ge sp op nil = Some v.
+ t = E0 /\ m2 = m1 /\ eval_operation ge sp op nil m1 = Some v.
Proof.
intros. inversion H. inversion H6.
intuition. congruence.
@@ -173,7 +166,7 @@ Lemma inv_eval_Eop_1:
eval_expr ge sp le e m1 (Eop op (a1 ::: Enil)) t m2 v ->
exists v1,
eval_expr ge sp le e m1 a1 t m2 v1 /\
- eval_operation ge sp op (v1 :: nil) = Some v.
+ eval_operation ge sp op (v1 :: nil) m2 = Some v.
Proof.
intros.
inversion H. inversion H6. inversion H18.
@@ -187,7 +180,7 @@ Lemma inv_eval_Eop_2:
eval_expr ge sp le e m1 a1 t1 m2 v1 /\
eval_expr ge sp le e m2 a2 t2 m3 v2 /\
t3 = t1 ** t2 /\
- eval_operation ge sp op (v1 :: v2 :: nil) = Some v.
+ eval_operation ge sp op (v1 :: v2 :: nil) m3 = Some v.
Proof.
intros.
inversion H. subst. inversion H6. subst. inversion H8. subst.
@@ -229,9 +222,16 @@ Ltac SimplEval :=
Ltac InvEval H :=
generalize H; SimplEval; clear H.
-(** ** Admissible evaluation rules for the smart constructors *)
+(** * Correctness of the smart constructors *)
-(** All proofs follow a common pattern:
+(** We now show that the code generated by "smart constructor" functions
+ such as [Selection.notint] behaves as expected. Continuing the
+ [notint] example, we show that if the expression [e]
+ evaluates to some integer value [Vint n], then [Selection.notint e]
+ evaluates to a value [Vint (Int.not n)] which is indeed the integer
+ negation of the value of [e].
+
+ All proofs follow a common pattern:
- Reasoning by case over the result of the classification functions
(such as [add_match] for integer addition), gathering additional
information on the shape of the argument expressions in the non-default
@@ -244,55 +244,7 @@ Ltac InvEval H :=
by the smart constructor.
*)
-Theorem eval_negint:
- forall sp le e m1 a t m2 x,
- eval_expr ge sp le e m1 a t m2 (Vint x) ->
- eval_expr ge sp le e m1 (negint a) t m2 (Vint (Int.neg x)).
-Proof.
- TrivialOp negint.
-Qed.
-
-Theorem eval_negfloat:
- forall sp le e m1 a t m2 x,
- eval_expr ge sp le e m1 a t m2 (Vfloat x) ->
- eval_expr ge sp le e m1 (negfloat a) t m2 (Vfloat (Float.neg x)).
-Proof.
- TrivialOp negfloat.
-Qed.
-
-Theorem eval_absfloat:
- forall sp le e m1 a t m2 x,
- eval_expr ge sp le e m1 a t m2 (Vfloat x) ->
- eval_expr ge sp le e m1 (absfloat a) t m2 (Vfloat (Float.abs x)).
-Proof.
- TrivialOp absfloat.
-Qed.
-
-Theorem eval_intoffloat:
- forall sp le e m1 a t m2 x,
- eval_expr ge sp le e m1 a t m2 (Vfloat x) ->
- eval_expr ge sp le e m1 (intoffloat a) t m2 (Vint (Float.intoffloat x)).
-Proof.
- TrivialOp intoffloat.
-Qed.
-
-Theorem eval_floatofint:
- forall sp le e m1 a t m2 x,
- eval_expr ge sp le e m1 a t m2 (Vint x) ->
- eval_expr ge sp le e m1 (floatofint a) t m2 (Vfloat (Float.floatofint x)).
-Proof.
- TrivialOp floatofint.
-Qed.
-
-Theorem eval_floatofintu:
- forall sp le e m1 a t m2 x,
- eval_expr ge sp le e m1 a t m2 (Vint x) ->
- eval_expr ge sp le e m1 (floatofintu a) t m2 (Vfloat (Float.floatofintu x)).
-Proof.
- TrivialOp floatofintu.
-Qed.
-
-Theorem eval_notint:
+Lemma eval_notint:
forall sp le e m1 a t m2 x,
eval_expr ge sp le e m1 a t m2 (Vint x) ->
eval_expr ge sp le e m1 (notint a) t m2 (Vint (Int.not x)).
@@ -325,7 +277,7 @@ Qed.
Hint Resolve Val.bool_of_true_val Val.bool_of_false_val
Val.bool_of_true_val_inv Val.bool_of_false_val_inv: valboolof.
-Theorem eval_notbool:
+Lemma eval_notbool:
forall a sp le e m1 t m2 v b,
eval_expr ge sp le e m1 a t m2 v ->
Val.bool_of_val v b ->
@@ -349,11 +301,11 @@ Proof.
inversion H. subst.
simpl in H11. eapply eval_Eop; eauto.
- simpl. caseEq (eval_condition c vl); intros.
+ simpl. caseEq (eval_condition c vl m2); intros.
rewrite H1 in H11.
assert (b0 = b).
destruct b0; inversion H11; subst v; inversion H0; auto.
- subst b0. rewrite (Op.eval_negate_condition _ _ H1).
+ subst b0. rewrite (Op.eval_negate_condition _ _ _ H1).
destruct b; reflexivity.
rewrite H1 in H11; discriminate.
@@ -364,7 +316,7 @@ Proof.
destruct v4; eauto. auto.
Qed.
-Theorem eval_addimm:
+Lemma eval_addimm:
forall sp le e m1 n a t m2 x,
eval_expr ge sp le e m1 a t m2 (Vint x) ->
eval_expr ge sp le e m1 (addimm n a) t m2 (Vint (Int.add x n)).
@@ -382,7 +334,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_addimm_ptr:
+Lemma eval_addimm_ptr:
forall sp le e m1 n t a m2 b ofs,
eval_expr ge sp le e m1 a t m2 (Vptr b ofs) ->
eval_expr ge sp le e m1 (addimm n a) t m2 (Vptr b (Int.add ofs n)).
@@ -404,7 +356,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_add:
+Lemma eval_add:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -431,7 +383,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_add_ptr:
+Lemma eval_add_ptr:
forall sp le e m1 a t1 m2 p x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vptr p x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -456,7 +408,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_add_ptr_2:
+Lemma eval_add_ptr_2:
forall sp le e m1 a t1 m2 p x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vptr p y) ->
@@ -483,7 +435,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_sub:
+Lemma eval_sub:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -511,7 +463,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_sub_ptr_int:
+Lemma eval_sub_ptr_int:
forall sp le e m1 a t1 m2 p x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vptr p x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -540,7 +492,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_sub_ptr_ptr:
+Lemma eval_sub_ptr_ptr:
forall sp le e m1 a t1 m2 p x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vptr p x) ->
eval_expr ge sp le e m2 b t2 m3 (Vptr p y) ->
@@ -589,7 +541,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_shlimm:
+Lemma eval_shlimm:
forall sp le e m1 a n t m2 x,
eval_expr ge sp le e m1 a t m2 (Vint x) ->
Int.ltu n (Int.repr 32) = true ->
@@ -603,7 +555,7 @@ Proof.
apply eval_rolm. auto. symmetry. apply Int.shl_rolm. exact H0.
Qed.
-Theorem eval_shruimm:
+Lemma eval_shruimm:
forall sp le e m1 a n t m2 x,
eval_expr ge sp le e m1 a t m2 (Vint x) ->
Int.ltu n (Int.repr 32) = true ->
@@ -649,7 +601,7 @@ Proof.
intros. EvalOp.
Qed.
-Theorem eval_mulimm:
+Lemma eval_mulimm:
forall sp le e m1 a n t m2 x,
eval_expr ge sp le e m1 a t m2 (Vint x) ->
eval_expr ge sp le e m1 (mulimm n a) t m2 (Vint (Int.mul x n)).
@@ -669,7 +621,7 @@ Proof.
apply eval_mulimm_base. assumption.
Qed.
-Theorem eval_mul:
+Lemma eval_mul:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -683,7 +635,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_divs:
+Lemma eval_divs:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -696,9 +648,9 @@ Qed.
Lemma eval_mod_aux:
forall divop semdivop,
- (forall sp x y,
+ (forall sp x y m,
y <> Int.zero ->
- eval_operation ge sp divop (Vint x :: Vint y :: nil) =
+ eval_operation ge sp divop (Vint x :: Vint y :: nil) m =
Some (Vint (semdivop x y))) ->
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
@@ -725,7 +677,7 @@ Proof.
reflexivity. traceEq.
Qed.
-Theorem eval_mods:
+Lemma eval_mods:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -750,7 +702,7 @@ Proof.
predSpec Int.eq Int.eq_spec y Int.zero. contradiction. auto.
Qed.
-Theorem eval_divu:
+Lemma eval_divu:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -767,7 +719,7 @@ Proof.
eapply eval_divu_base; eauto.
Qed.
-Theorem eval_modu:
+Lemma eval_modu:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -788,7 +740,7 @@ Proof.
eexact H. eexact H0. auto. auto.
Qed.
-Theorem eval_andimm:
+Lemma eval_andimm:
forall sp le e m1 n a t m2 x,
eval_expr ge sp le e m1 a t m2 (Vint x) ->
eval_expr ge sp le e m1 (andimm n a) t m2 (Vint (Int.and x n)).
@@ -798,7 +750,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_and:
+Lemma eval_and:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -848,14 +800,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_xor:
- forall sp le e m1 a t1 m2 x b t2 m3 y,
- eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
- eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
- eval_expr ge sp le e m1 (xor a b) (t1**t2) m3 (Vint (Int.xor x y)).
-Proof. TrivialOp xor. Qed.
-
-Theorem eval_shl:
+Lemma eval_shl:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -867,17 +812,7 @@ Proof.
EvalOp. simpl. rewrite H1. auto.
Qed.
-Theorem eval_shr:
- forall sp le e m1 a t1 m2 x b t2 m3 y,
- eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
- eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
- Int.ltu y (Int.repr 32) = true ->
- eval_expr ge sp le e m1 (shr a b) (t1**t2) m3 (Vint (Int.shr x y)).
-Proof.
- TrivialOp shr. simpl. rewrite H1. auto.
-Qed.
-
-Theorem eval_shru:
+Lemma eval_shru:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
@@ -889,7 +824,7 @@ Proof.
EvalOp. simpl. rewrite H1. auto.
Qed.
-Theorem eval_addf:
+Lemma eval_addf:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vfloat x) ->
eval_expr ge sp le e m2 b t2 m3 (Vfloat y) ->
@@ -908,7 +843,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_subf:
+Lemma eval_subf:
forall sp le e m1 a t1 m2 x b t2 m3 y,
eval_expr ge sp le e m1 a t1 m2 (Vfloat x) ->
eval_expr ge sp le e m2 b t2 m3 (Vfloat y) ->
@@ -921,21 +856,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_mulf:
- forall sp le e m1 a t1 m2 x b t2 m3 y,
- eval_expr ge sp le e m1 a t1 m2 (Vfloat x) ->
- eval_expr ge sp le e m2 b t2 m3 (Vfloat y) ->
- eval_expr ge sp le e m1 (mulf a b) (t1**t2) m3 (Vfloat (Float.mul x y)).
-Proof. TrivialOp mulf. Qed.
-
-Theorem eval_divf:
- forall sp le e m1 a t1 m2 x b t2 m3 y,
- eval_expr ge sp le e m1 a t1 m2 (Vfloat x) ->
- eval_expr ge sp le e m2 b t2 m3 (Vfloat y) ->
- eval_expr ge sp le e m1 (divf a b) (t1**t2) m3 (Vfloat (Float.div x y)).
-Proof. TrivialOp divf. Qed.
-
-Theorem eval_cast8signed:
+Lemma eval_cast8signed:
forall sp le e m1 a t m2 v,
eval_expr ge sp le e m1 a t m2 v ->
eval_expr ge sp le e m1 (cast8signed a) t m2 (Val.cast8signed v).
@@ -946,7 +867,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_cast8unsigned:
+Lemma eval_cast8unsigned:
forall sp le e m1 a t m2 v,
eval_expr ge sp le e m1 a t m2 v ->
eval_expr ge sp le e m1 (cast8unsigned a) t m2 (Val.cast8unsigned v).
@@ -957,7 +878,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_cast16signed:
+Lemma eval_cast16signed:
forall sp le e m1 a t m2 v,
eval_expr ge sp le e m1 a t m2 v ->
eval_expr ge sp le e m1 (cast16signed a) t m2 (Val.cast16signed v).
@@ -968,7 +889,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_cast16unsigned:
+Lemma eval_cast16unsigned:
forall sp le e m1 a t m2 v,
eval_expr ge sp le e m1 a t m2 v ->
eval_expr ge sp le e m1 (cast16unsigned a) t m2 (Val.cast16unsigned v).
@@ -979,7 +900,7 @@ Proof.
EvalOp.
Qed.
-Theorem eval_singleoffloat:
+Lemma eval_singleoffloat:
forall sp le e m1 a t m2 v,
eval_expr ge sp le e m1 a t m2 v ->
eval_expr ge sp le e m1 (singleoffloat a) t m2 (Val.singleoffloat v).
@@ -990,75 +911,12 @@ Proof.
EvalOp.
Qed.
-Theorem eval_cmp:
- forall sp le c e m1 a t1 m2 x b t2 m3 y,
- eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
- eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
- eval_expr ge sp le e m1 (cmp c a b) (t1**t2) m3 (Val.of_bool (Int.cmp c x y)).
-Proof.
- TrivialOp cmp.
- simpl. case (Int.cmp c x y); auto.
-Qed.
-
-Theorem eval_cmp_null_r:
- forall sp le c e m1 a t1 m2 p x b t2 m3 v,
- eval_expr ge sp le e m1 a t1 m2 (Vptr p x) ->
- eval_expr ge sp le e m2 b t2 m3 (Vint Int.zero) ->
- (c = Ceq /\ v = Vfalse) \/ (c = Cne /\ v = Vtrue) ->
- eval_expr ge sp le e m1 (cmp c a b) (t1**t2) m3 v.
-Proof.
- TrivialOp cmp.
- simpl. elim H1; intros [EQ1 EQ2]; subst c; subst v; reflexivity.
-Qed.
-
-Theorem eval_cmp_null_l:
- forall sp le c e m1 a t1 m2 p x b t2 m3 v,
- eval_expr ge sp le e m1 a t1 m2 (Vint Int.zero) ->
- eval_expr ge sp le e m2 b t2 m3 (Vptr p x) ->
- (c = Ceq /\ v = Vfalse) \/ (c = Cne /\ v = Vtrue) ->
- eval_expr ge sp le e m1 (cmp c a b) (t1**t2) m3 v.
-Proof.
- TrivialOp cmp.
- simpl. elim H1; intros [EQ1 EQ2]; subst c; subst v; reflexivity.
-Qed.
-
-Theorem eval_cmp_ptr:
- forall sp le c e m1 a t1 m2 p x b t2 m3 y,
- eval_expr ge sp le e m1 a t1 m2 (Vptr p x) ->
- eval_expr ge sp le e m2 b t2 m3 (Vptr p y) ->
- eval_expr ge sp le e m1 (cmp c a b) (t1**t2) m3 (Val.of_bool (Int.cmp c x y)).
-Proof.
- TrivialOp cmp.
- simpl. unfold eq_block. rewrite zeq_true.
- case (Int.cmp c x y); auto.
-Qed.
-
-Theorem eval_cmpu:
- forall sp le c e m1 a t1 m2 x b t2 m3 y,
- eval_expr ge sp le e m1 a t1 m2 (Vint x) ->
- eval_expr ge sp le e m2 b t2 m3 (Vint y) ->
- eval_expr ge sp le e m1 (cmpu c a b) (t1**t2) m3 (Val.of_bool (Int.cmpu c x y)).
-Proof.
- TrivialOp cmpu.
- simpl. case (Int.cmpu c x y); auto.
-Qed.
-
-Theorem eval_cmpf:
- forall sp le c e m1 a t1 m2 x b t2 m3 y,
- eval_expr ge sp le e m1 a t1 m2 (Vfloat x) ->
- eval_expr ge sp le e m2 b t2 m3 (Vfloat y) ->
- eval_expr ge sp le e m1 (cmpf c a b) (t1**t2) m3 (Val.of_bool (Float.cmp c x y)).
-Proof.
- TrivialOp cmpf.
- simpl. case (Float.cmp c x y); auto.
-Qed.
-
Lemma eval_base_condition_of_expr:
forall sp le a e m1 t m2 v (b: bool),
eval_expr ge sp le e m1 a t m2 v ->
Val.bool_of_val v b ->
eval_condexpr ge sp le e m1
- (CEcond (Ccompuimm Cne Int.zero) (a ::: Enil))
+ (CEcond (Ccompimm Cne Int.zero) (a ::: Enil))
t m2 b.
Proof.
intros.
@@ -1090,30 +948,6 @@ Proof.
destruct v1; eauto with evalexpr.
Qed.
-Theorem eval_conditionalexpr_true:
- forall sp le e m1 a1 t1 m2 v1 t2 a2 m3 v2 a3,
- eval_expr ge sp le e m1 a1 t1 m2 v1 ->
- Val.is_true v1 ->
- eval_expr ge sp le e m2 a2 t2 m3 v2 ->
- eval_expr ge sp le e m1 (conditionalexpr a1 a2 a3) (t1**t2) m3 v2.
-Proof.
- intros; unfold conditionalexpr.
- apply eval_Econdition with t1 m2 true t2; auto.
- eapply eval_condition_of_expr; eauto with valboolof.
-Qed.
-
-Theorem eval_conditionalexpr_false:
- forall sp le e m1 a1 t1 m2 v1 a2 t2 m3 v2 a3,
- eval_expr ge sp le e m1 a1 t1 m2 v1 ->
- Val.is_false v1 ->
- eval_expr ge sp le e m2 a3 t2 m3 v2 ->
- eval_expr ge sp le e m1 (conditionalexpr a1 a2 a3) (t1**t2) m3 v2.
-Proof.
- intros; unfold conditionalexpr.
- apply eval_Econdition with t1 m2 false t2; auto.
- eapply eval_condition_of_expr; eauto with valboolof.
-Qed.
-
Lemma eval_addressing:
forall sp le e m1 a t m2 v b ofs,
eval_expr ge sp le e m1 a t m2 v ->
@@ -1150,7 +984,7 @@ Proof.
subst v. simpl. rewrite Int.add_zero. auto.
Qed.
-Theorem eval_load:
+Lemma eval_load:
forall sp le e m1 a t m2 v chunk v',
eval_expr ge sp le e m1 a t m2 v ->
Mem.loadv chunk m2 v = Some v' ->
@@ -1163,7 +997,7 @@ Proof.
eapply eval_Eload; eauto.
Qed.
-Theorem eval_store:
+Lemma eval_store:
forall sp le e m1 a1 t1 m2 v1 a2 t2 m3 v2 chunk m4,
eval_expr ge sp le e m1 a1 t1 m2 v1 ->
eval_expr ge sp le e m2 a2 t2 m3 v2 ->
@@ -1177,31 +1011,230 @@ Proof.
eapply eval_Estore; eauto.
Qed.
-Theorem exec_ifthenelse_true:
- forall sp e m1 a t1 m2 v ifso ifnot t2 e3 m3 out,
- eval_expr ge sp nil e m1 a t1 m2 v ->
- Val.is_true v ->
- exec_stmt ge sp e m2 ifso t2 e3 m3 out ->
- exec_stmt ge sp e m1 (ifthenelse a ifso ifnot) (t1**t2) e3 m3 out.
+(** * Correctness of instruction selection for operators *)
+
+(** We now prove a semantic preservation result for the [sel_unop]
+ and [sel_binop] selection functions. The proof exploits
+ the results of the previous section. *)
+
+Lemma eval_sel_unop:
+ forall sp le e m op a1 t m1 v1 v,
+ eval_expr ge sp le e m a1 t m1 v1 ->
+ eval_unop op v1 = Some v ->
+ eval_expr ge sp le e m (sel_unop op a1) t m1 v.
Proof.
- intros. unfold ifthenelse.
- apply exec_Sifthenelse with t1 m2 true t2.
- eapply eval_condition_of_expr; eauto with valboolof.
- auto. auto.
+ destruct op; simpl; intros; FuncInv; try subst v.
+ apply eval_cast8unsigned; auto.
+ apply eval_cast8signed; auto.
+ apply eval_cast16unsigned; auto.
+ apply eval_cast16signed; auto.
+ EvalOp.
+ generalize (Int.eq_spec i Int.zero). destruct (Int.eq i Int.zero); intro.
+ change true with (negb false). eapply eval_notbool; eauto. subst i; constructor.
+ change false with (negb true). eapply eval_notbool; eauto. constructor; auto.
+ change Vfalse with (Val.of_bool (negb true)).
+ eapply eval_notbool; eauto. constructor.
+ apply eval_notint; auto.
+ EvalOp.
+ EvalOp.
+ apply eval_singleoffloat; auto.
+ EvalOp.
+ EvalOp.
+ EvalOp.
Qed.
-Theorem exec_ifthenelse_false:
- forall sp e m1 a t1 m2 v ifso ifnot t2 e3 m3 out,
- eval_expr ge sp nil e m1 a t1 m2 v ->
- Val.is_false v ->
- exec_stmt ge sp e m2 ifnot t2 e3 m3 out ->
- exec_stmt ge sp e m1 (ifthenelse a ifso ifnot) (t1**t2) e3 m3 out.
+Lemma eval_sel_binop:
+ forall sp le e m op a1 a2 t1 m1 v1 t2 m2 v2 v,
+ eval_expr ge sp le e m a1 t1 m1 v1 ->
+ eval_expr ge sp le e m1 a2 t2 m2 v2 ->
+ eval_binop op v1 v2 m2 = Some v ->
+ eval_expr ge sp le e m (sel_binop op a1 a2) (t1 ** t2) m2 v.
Proof.
- intros. unfold ifthenelse.
- apply exec_Sifthenelse with t1 m2 false t2.
- eapply eval_condition_of_expr; eauto with valboolof.
- auto. auto.
+ destruct op; simpl; intros; FuncInv; try subst v.
+ eapply eval_add; eauto.
+ eapply eval_add_ptr_2; eauto.
+ eapply eval_add_ptr; eauto.
+ eapply eval_sub; eauto.
+ eapply eval_sub_ptr_int; eauto.
+ destruct (eq_block b b0); inv H1.
+ eapply eval_sub_ptr_ptr; eauto.
+ eapply eval_mul; eauto.
+ generalize (Int.eq_spec i0 Int.zero). intro. destruct (Int.eq i0 Int.zero); inv H1.
+ eapply eval_divs; eauto.
+ generalize (Int.eq_spec i0 Int.zero). intro. destruct (Int.eq i0 Int.zero); inv H1.
+ eapply eval_divu; eauto.
+ generalize (Int.eq_spec i0 Int.zero). intro. destruct (Int.eq i0 Int.zero); inv H1.
+ eapply eval_mods; eauto.
+ generalize (Int.eq_spec i0 Int.zero). intro. destruct (Int.eq i0 Int.zero); inv H1.
+ eapply eval_modu; eauto.
+ eapply eval_and; eauto.
+ eapply eval_or; eauto.
+ EvalOp.
+ caseEq (Int.ltu i0 (Int.repr 32)); intro; rewrite H2 in H1; inv H1.
+ eapply eval_shl; eauto.
+ EvalOp.
+ caseEq (Int.ltu i0 (Int.repr 32)); intro; rewrite H2 in H1; inv H1.
+ eapply eval_shru; eauto.
+ eapply eval_addf; eauto.
+ eapply eval_subf; eauto.
+ EvalOp.
+ EvalOp.
+ EvalOp. simpl. destruct (Int.cmp c i i0); auto.
+ EvalOp. simpl. generalize H1; unfold eval_compare_null, Cminor.eval_compare_null.
+ destruct (Int.eq i Int.zero). destruct c; intro EQ; inv EQ; auto.
+ auto.
+ EvalOp. simpl. generalize H1; unfold eval_compare_null, Cminor.eval_compare_null.
+ destruct (Int.eq i0 Int.zero). destruct c; intro EQ; inv EQ; auto.
+ auto.
+ EvalOp. simpl.
+ destruct (valid_pointer m2 b (Int.signed i) && valid_pointer m2 b0 (Int.signed i0)).
+ destruct (eq_block b b0); inv H1.
+ destruct (Int.cmp c i i0); auto.
+ auto.
+ EvalOp. simpl. destruct (Int.cmpu c i i0); auto.
+ EvalOp. simpl. destruct (Float.cmp c f f0); auto.
Qed.
End CMCONSTR.
+(** * Semantic preservation for instruction selection. *)
+
+Section PRESERVATION.
+
+Variable prog: Cminor.program.
+Let tprog := sel_program prog.
+Let ge := Genv.globalenv prog.
+Let tge := Genv.globalenv tprog.
+
+(** Relationship between the global environments for the original
+ CminorSel program and the generated RTL program. *)
+
+Lemma symbols_preserved:
+ forall (s: ident), Genv.find_symbol tge s = Genv.find_symbol ge s.
+Proof.
+ intros; unfold ge, tge, tprog, sel_program.
+ apply Genv.find_symbol_transf.
+Qed.
+
+Lemma functions_translated:
+ forall (v: val) (f: Cminor.fundef),
+ Genv.find_funct ge v = Some f ->
+ Genv.find_funct tge v = Some (sel_fundef f).
+Proof.
+ intros.
+ exact (Genv.find_funct_transf sel_fundef H).
+Qed.
+
+Lemma function_ptr_translated:
+ forall (b: block) (f: Cminor.fundef),
+ Genv.find_funct_ptr ge b = Some f ->
+ Genv.find_funct_ptr tge b = Some (sel_fundef f).
+Proof.
+ intros.
+ exact (Genv.find_funct_ptr_transf sel_fundef H).
+Qed.
+
+Lemma sig_function_translated:
+ forall f,
+ funsig (sel_fundef f) = Cminor.funsig f.
+Proof.
+ intros. destruct f; reflexivity.
+Qed.
+
+(** This is the main semantic preservation theorem:
+ instruction selection preserves the semantics of function invocations.
+ The proof is an induction over the Cminor evaluation derivation. *)
+
+Lemma sel_function_correct:
+ forall m fd vargs t m' vres,
+ Cminor.eval_funcall ge m fd vargs t m' vres ->
+ CminorSel.eval_funcall tge m (sel_fundef fd) vargs t m' vres.
+Proof.
+ apply (Cminor.eval_funcall_ind4 ge
+ (fun sp le e m a t m' v => eval_expr tge sp le e m (sel_expr a) t m' v)
+ (fun sp le e m a t m' v => eval_exprlist tge sp le e m (sel_exprlist a) t m' v)
+ (fun m fd vargs t m' vres => eval_funcall tge m (sel_fundef fd) vargs t m' vres)
+ (fun sp e m s t e' m' out => exec_stmt tge sp e m (sel_stmt s) t e' m' out));
+ intros; simpl.
+ (* Evar *)
+ constructor; auto.
+ (* Econst *)
+ destruct cst; simpl; simpl in H; (econstructor; [constructor|simpl;auto]).
+ rewrite symbols_preserved. auto.
+ (* Eunop *)
+ eapply eval_sel_unop; eauto.
+ (* Ebinop *)
+ subst t. eapply eval_sel_binop; eauto.
+ (* Eload *)
+ eapply eval_load; eauto.
+ (* Estore *)
+ subst t. eapply eval_store; eauto.
+ (* Ecall *)
+ econstructor; eauto. apply functions_translated; auto.
+ rewrite <- H4. apply sig_function_translated.
+ (* Econdition *)
+ econstructor; eauto. eapply eval_condition_of_expr; eauto.
+ destruct b1; auto.
+ (* Elet *)
+ econstructor; eauto.
+ (* Eletvar *)
+ constructor; auto.
+ (* Ealloc *)
+ econstructor; eauto.
+ (* Enil *)
+ constructor.
+ (* Econs *)
+ econstructor; eauto.
+ (* Internal function *)
+ econstructor; eauto.
+ (* External function *)
+ econstructor; eauto.
+ (* Sskip *)
+ constructor.
+ (* Sexpr *)
+ econstructor; eauto.
+ (* Sassign *)
+ econstructor; eauto.
+ (* Sifthenelse *)
+ econstructor; eauto. eapply eval_condition_of_expr; eauto.
+ destruct b1; auto.
+ (* Sseq *)
+ eapply exec_Sseq_continue; eauto.
+ eapply exec_Sseq_stop; eauto.
+ (* Sloop *)
+ eapply exec_Sloop_loop; eauto.
+ eapply exec_Sloop_stop; eauto.
+ (* Sblock *)
+ econstructor; eauto.
+ (* Sexit *)
+ constructor.
+ (* Sswitch *)
+ econstructor; eauto.
+ (* Sreturn *)
+ constructor.
+ econstructor; eauto.
+ (* Stailcall *)
+ econstructor; eauto. apply functions_translated; auto.
+ rewrite <- H4. apply sig_function_translated.
+Qed.
+
+End PRESERVATION.
+
+(** As a corollary, instruction selection preserves the observable
+ behaviour of programs. *)
+
+Theorem sel_program_correct:
+ forall prog t r,
+ Cminor.exec_program prog t r ->
+ CminorSel.exec_program (sel_program prog) t r.
+Proof.
+ intros.
+ destruct H as [b [f [m [FINDS [FINDF [SIG EXEC]]]]]].
+ exists b; exists (sel_fundef f); exists m.
+ split. simpl. rewrite <- FINDS. apply symbols_preserved.
+ split. apply function_ptr_translated. auto.
+ split. rewrite <- SIG. apply sig_function_translated.
+ replace (Genv.init_mem (sel_program prog)) with (Genv.init_mem prog).
+ apply sel_function_correct; auto.
+ symmetry. unfold sel_program. apply Genv.init_mem_transf.
+Qed.
diff --git a/backend/Stacking.v b/backend/Stacking.v
index de350dc1e266f05d15c1a1fb4a0977aa3d4cc6f1..c19e293f5113a5a0dca48379d58a71926de56424 100644
--- a/backend/Stacking.v
+++ b/backend/Stacking.v
@@ -2,13 +2,14 @@
Require Import Coqlib.
Require Import Maps.
+Require Import Errors.
Require Import AST.
Require Import Integers.
Require Import Op.
Require Import RTL.
Require Import Locations.
Require Import Linear.
-Require Import Lineartyping.
+Require Import Bounds.
Require Import Mach.
Require Import Conventions.
@@ -87,43 +88,61 @@ Definition offset_of_index (fe: frame_env) (idx: frame_index) :=
store in the frame the values of callee-save registers used by the
current function. *)
-Definition save_int_callee_save (fe: frame_env) (cs: mreg) (k: Mach.code) :=
- let i := index_int_callee_save cs in
- if zlt i fe.(fe_num_int_callee_save)
- then Msetstack cs (Int.repr (offset_of_index fe (FI_saved_int i))) Tint :: k
+Definition save_callee_save_reg
+ (bound: frame_env -> Z) (number: mreg -> Z) (mkindex: Z -> frame_index)
+ (ty: typ) (fe: frame_env) (cs: mreg) (k: Mach.code) :=
+ let i := number cs in
+ if zlt i (bound fe)
+ then Msetstack cs (Int.repr (offset_of_index fe (mkindex i))) ty :: k
else k.
-Definition save_float_callee_save (fe: frame_env) (cs: mreg) (k: Mach.code) :=
- let i := index_float_callee_save cs in
- if zlt i fe.(fe_num_float_callee_save)
- then Msetstack cs (Int.repr (offset_of_index fe (FI_saved_float i))) Tfloat :: k
- else k.
+Definition save_callee_save_regs
+ (bound: frame_env -> Z) (number: mreg -> Z) (mkindex: Z -> frame_index)
+ (ty: typ) (fe: frame_env) (csl: list mreg) (k: Mach.code) :=
+ List.fold_right (save_callee_save_reg bound number mkindex ty fe) k csl.
+
+Definition save_callee_save_int (fe: frame_env) :=
+ save_callee_save_regs
+ fe_num_int_callee_save index_int_callee_save FI_saved_int
+ Tint fe int_callee_save_regs.
+
+Definition save_callee_save_float (fe: frame_env) :=
+ save_callee_save_regs
+ fe_num_float_callee_save index_float_callee_save FI_saved_float
+ Tfloat fe float_callee_save_regs.
Definition save_callee_save (fe: frame_env) (k: Mach.code) :=
- List.fold_right (save_int_callee_save fe)
- (List.fold_right (save_float_callee_save fe) k float_callee_save_regs)
- int_callee_save_regs.
+ save_callee_save_int fe (save_callee_save_float fe k).
(** [restore_callee_save fe k] adds before [k] the instructions that
re-load from the frame the values of callee-save registers used by the
current function, restoring these registers to their initial values. *)
-Definition restore_int_callee_save (fe: frame_env) (cs: mreg) (k: Mach.code) :=
- let i := index_int_callee_save cs in
- if zlt i fe.(fe_num_int_callee_save)
- then Mgetstack (Int.repr (offset_of_index fe (FI_saved_int i))) Tint cs :: k
+Definition restore_callee_save_reg
+ (bound: frame_env -> Z) (number: mreg -> Z) (mkindex: Z -> frame_index)
+ (ty: typ) (fe: frame_env) (cs: mreg) (k: Mach.code) :=
+ let i := number cs in
+ if zlt i (bound fe)
+ then Mgetstack (Int.repr (offset_of_index fe (mkindex i))) ty cs :: k
else k.
-Definition restore_float_callee_save (fe: frame_env) (cs: mreg) (k: Mach.code) :=
- let i := index_float_callee_save cs in
- if zlt i fe.(fe_num_float_callee_save)
- then Mgetstack (Int.repr (offset_of_index fe (FI_saved_float i))) Tfloat cs :: k
- else k.
+Definition restore_callee_save_regs
+ (bound: frame_env -> Z) (number: mreg -> Z) (mkindex: Z -> frame_index)
+ (ty: typ) (fe: frame_env) (csl: list mreg) (k: Mach.code) :=
+ List.fold_right (restore_callee_save_reg bound number mkindex ty fe) k csl.
+
+Definition restore_callee_save_int (fe: frame_env) :=
+ restore_callee_save_regs
+ fe_num_int_callee_save index_int_callee_save FI_saved_int
+ Tint fe int_callee_save_regs.
+
+Definition restore_callee_save_float (fe: frame_env) :=
+ restore_callee_save_regs
+ fe_num_float_callee_save index_float_callee_save FI_saved_float
+ Tfloat fe float_callee_save_regs.
Definition restore_callee_save (fe: frame_env) (k: Mach.code) :=
- List.fold_right (restore_int_callee_save fe)
- (List.fold_right (restore_float_callee_save fe) k float_callee_save_regs)
- int_callee_save_regs.
+ restore_callee_save_int fe (restore_callee_save_float fe k).
(** * Code transformation. *)
@@ -186,6 +205,8 @@ Definition transl_instr
Mstore chunk (transl_addr fe addr) args src :: k
| Lcall sig ros =>
Mcall sig ros :: k
+ | Ltailcall sig ros =>
+ restore_callee_save fe (Mtailcall sig ros :: k)
| Lalloc =>
Malloc :: k
| Llabel lbl =>
@@ -214,18 +235,23 @@ Definition transl_code
Definition transl_body (f: Linear.function) (fe: frame_env) :=
save_callee_save fe (transl_code fe f.(Linear.fn_code)).
-Definition transf_function (f: Linear.function) : option Mach.function :=
+Open Local Scope string_scope.
+
+Definition transf_function (f: Linear.function) : res Mach.function :=
let fe := make_env (function_bounds f) in
- if zlt f.(Linear.fn_stacksize) 0 then None else
- if zlt (- Int.min_signed) fe.(fe_size) then None else
- Some (Mach.mkfunction
+ if zlt f.(Linear.fn_stacksize) 0 then
+ Error (msg "Stacking.transf_function")
+ else if zlt (- Int.min_signed) fe.(fe_size) then
+ Error (msg "Too many spilled variables, stack size exceeded")
+ else
+ OK (Mach.mkfunction
f.(Linear.fn_sig)
(transl_body f fe)
f.(Linear.fn_stacksize)
fe.(fe_size)).
-Definition transf_fundef (f: Linear.fundef) : option Mach.fundef :=
+Definition transf_fundef (f: Linear.fundef) : res Mach.fundef :=
AST.transf_partial_fundef transf_function f.
-Definition transf_program (p: Linear.program) : option Mach.program :=
+Definition transf_program (p: Linear.program) : res Mach.program :=
transform_partial_program transf_fundef p.
diff --git a/backend/Stackingproof.v b/backend/Stackingproof.v
index 3bc4339bc9bd9e894d5b373f5bc8affc2ba914dd..905570ef86fc050498fa15b40bc0475cc7fd38d9 100644
--- a/backend/Stackingproof.v
+++ b/backend/Stackingproof.v
@@ -1,15 +1,16 @@
(** Correctness proof for the translation from Linear to Mach. *)
(** This file proves semantic preservation for the [Stacking] pass.
- For the target language Mach, we use the alternate semantics
+ For the target language Mach, we use the abstract semantics
given in file [Machabstr], where a part of the activation record
is not resident in memory. Combined with the semantic equivalence
- result between the two Mach semantics (see file [Machabstr2mach]),
+ result between the two Mach semantics (see file [Machabstr2concr]),
the proof in this file also shows semantic preservation with
- respect to the standard Mach semantics. *)
+ respect to the concrete Mach semantics. *)
Require Import Coqlib.
Require Import Maps.
+Require Import Errors.
Require Import AST.
Require Import Integers.
Require Import Values.
@@ -17,11 +18,13 @@ Require Import Op.
Require Import Mem.
Require Import Events.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Locations.
-Require Import Mach.
-Require Import Machabstr.
Require Import Linear.
Require Import Lineartyping.
+Require Import Mach.
+Require Import Machabstr.
+Require Import Bounds.
Require Import Conventions.
Require Import Stacking.
@@ -29,25 +32,28 @@ Require Import Stacking.
(** ``Good variable'' properties for frame accesses. *)
+Lemma typesize_typesize:
+ forall ty, AST.typesize ty = 4 * Locations.typesize ty.
+Proof.
+ destruct ty; auto.
+Qed.
+
Lemma get_slot_ok:
forall fr ty ofs,
- 0 <= ofs -> fr.(low) + ofs + 4 * typesize ty <= 0 ->
+ 24 <= ofs -> fr.(fr_low) + ofs + 4 * typesize ty <= 0 ->
exists v, get_slot fr ty ofs v.
Proof.
- intros. exists (load_contents (mem_type ty) fr.(contents) (fr.(low) + ofs)).
- constructor; auto.
+ intros. rewrite <- typesize_typesize in H0.
+ exists (fr.(fr_contents) ty (fr.(fr_low) + ofs)). constructor; auto.
Qed.
Lemma set_slot_ok:
forall fr ty ofs v,
- fr.(high) = 0 -> 0 <= ofs -> fr.(low) + ofs + 4 * typesize ty <= 0 ->
+ 24 <= ofs -> fr.(fr_low) + ofs + 4 * typesize ty <= 0 ->
exists fr', set_slot fr ty ofs v fr'.
Proof.
- intros.
- exists (mkblock fr.(low) fr.(high)
- (store_contents (mem_type ty) fr.(contents) (fr.(low) + ofs) v)
- (set_slot_undef_outside fr ty ofs v H H0 H1 fr.(undef_outside))).
- constructor; auto.
+ intros. rewrite <- typesize_typesize in H0.
+ econstructor. constructor; eauto.
Qed.
Lemma slot_gss:
@@ -55,10 +61,45 @@ Lemma slot_gss:
set_slot fr1 ty ofs v fr2 ->
get_slot fr2 ty ofs v.
Proof.
- intros. induction H.
- constructor.
- auto. simpl. auto.
- simpl. symmetry. apply load_store_contents_same.
+ intros. inv H. constructor; auto.
+ simpl. destruct (typ_eq ty ty); try congruence.
+ rewrite zeq_true. auto.
+Qed.
+
+Remark frame_update_gso:
+ forall fr ty ofs v ty' ofs',
+ ofs' + 4 * typesize ty' <= ofs \/ ofs + 4 * typesize ty <= ofs' ->
+ fr_contents (update ty ofs v fr) ty' ofs' = fr_contents fr ty' ofs'.
+Proof.
+ intros.
+ generalize (typesize_pos ty); intro.
+ generalize (typesize_pos ty'); intro.
+ simpl. rewrite zeq_false. 2: omega.
+ repeat rewrite <- typesize_typesize in H.
+ destruct (zle (ofs' + AST.typesize ty') ofs). auto.
+ destruct (zle (ofs + AST.typesize ty) ofs'). auto.
+ omegaContradiction.
+Qed.
+
+Remark frame_update_overlap:
+ forall fr ty ofs v ty' ofs',
+ ofs <> ofs' ->
+ ofs' + 4 * typesize ty' > ofs -> ofs + 4 * typesize ty > ofs' ->
+ fr_contents (update ty ofs v fr) ty' ofs' = Vundef.
+Proof.
+ intros. simpl. rewrite zeq_false; auto.
+ rewrite <- typesize_typesize in H0.
+ rewrite <- typesize_typesize in H1.
+ repeat rewrite zle_false; auto.
+Qed.
+
+Remark frame_update_mismatch:
+ forall fr ty ofs v ty',
+ ty <> ty' ->
+ fr_contents (update ty ofs v fr) ty' ofs = Vundef.
+Proof.
+ intros. simpl. rewrite zeq_true.
+ destruct (typ_eq ty ty'); congruence.
Qed.
Lemma slot_gso:
@@ -68,38 +109,36 @@ Lemma slot_gso:
ofs' + 4 * typesize ty' <= ofs \/ ofs + 4 * typesize ty <= ofs' ->
get_slot fr2 ty' ofs' v'.
Proof.
- intros. induction H; inversion H0.
- constructor.
- auto. simpl low. auto.
- simpl. rewrite H3. symmetry. apply load_store_contents_other.
- repeat (rewrite size_mem_type). omega.
+ intros. inv H. inv H0.
+ constructor; auto.
+ symmetry. simpl fr_low. apply frame_update_gso. omega.
Qed.
Lemma slot_gi:
forall f ofs ty,
- 0 <= ofs -> (init_frame f).(low) + ofs + 4 * typesize ty <= 0 ->
+ 24 <= ofs -> fr_low (init_frame f) + ofs + 4 * typesize ty <= 0 ->
get_slot (init_frame f) ty ofs Vundef.
Proof.
- intros. constructor.
- auto. auto.
- symmetry. apply load_contents_init.
+ intros. rewrite <- typesize_typesize in H0. constructor; auto.
Qed.
Section PRESERVATION.
Variable prog: Linear.program.
Variable tprog: Mach.program.
-Hypothesis TRANSF: transf_program prog = Some tprog.
+Hypothesis TRANSF: transf_program prog = OK tprog.
Let ge := Genv.globalenv prog.
Let tge := Genv.globalenv tprog.
+
Section FRAME_PROPERTIES.
+Variable stack: list Machabstr.stackframe.
Variable f: Linear.function.
Let b := function_bounds f.
Let fe := make_env b.
Variable tf: Mach.function.
-Hypothesis TRANSF_F: transf_function f = Some tf.
+Hypothesis TRANSF_F: transf_function f = OK tf.
Lemma unfold_transf_function:
tf = Mach.mkfunction
@@ -109,7 +148,7 @@ Lemma unfold_transf_function:
fe.(fe_size).
Proof.
generalize TRANSF_F. unfold transf_function.
- case (zlt (fn_stacksize f) 0). intros; discriminate.
+ case (zlt (Linear.fn_stacksize f) 0). intros; discriminate.
case (zlt (- Int.min_signed) (fe_size (make_env (function_bounds f)))).
intros; discriminate.
intros. unfold fe. unfold b. congruence.
@@ -118,7 +157,7 @@ Qed.
Lemma size_no_overflow: fe.(fe_size) <= -Int.min_signed.
Proof.
generalize TRANSF_F. unfold transf_function.
- case (zlt (fn_stacksize f) 0). intros; discriminate.
+ case (zlt (Linear.fn_stacksize f) 0). intros; discriminate.
case (zlt (- Int.min_signed) (fe_size (make_env (function_bounds f)))).
intros; discriminate.
intros. unfold fe, b. omega.
@@ -131,7 +170,7 @@ Definition index_valid (idx: frame_index) :=
match idx with
| FI_local x Tint => 0 <= x < b.(bound_int_local)
| FI_local x Tfloat => 0 <= x < b.(bound_float_local)
- | FI_arg x ty => 6 <= x /\ x + typesize ty <= b.(bound_outgoing)
+ | FI_arg x ty => 14 <= x /\ x + typesize ty <= b.(bound_outgoing)
| FI_saved_int x => 0 <= x < b.(bound_int_callee_save)
| FI_saved_float x => 0 <= x < b.(bound_float_callee_save)
end.
@@ -166,17 +205,12 @@ Proof.
Qed.
Ltac AddPosProps :=
- assert (bound_int_local b >= 0);
- [unfold b; apply bound_int_local_pos |
- assert (bound_float_local b >= 0);
- [unfold b; apply bound_float_local_pos |
- assert (bound_int_callee_save b >= 0);
- [unfold b; apply bound_int_callee_save_pos |
- assert (bound_float_callee_save b >= 0);
- [unfold b; apply bound_float_callee_save_pos |
- assert (bound_outgoing b >= 6);
- [unfold b; apply bound_outgoing_pos |
- generalize align_float_part; intro]]]]].
+ generalize (bound_int_local_pos b); intro;
+ generalize (bound_float_local_pos b); intro;
+ generalize (bound_int_callee_save_pos b); intro;
+ generalize (bound_float_callee_save_pos b); intro;
+ generalize (bound_outgoing_pos b); intro;
+ generalize align_float_part; intro.
Lemma size_pos: fe.(fe_size) >= 24.
Proof.
@@ -212,18 +246,18 @@ Qed.
Lemma index_local_valid:
forall ofs ty,
- slot_bounded f (Local ofs ty) ->
+ slot_within_bounds f b (Local ofs ty) ->
index_valid (FI_local ofs ty).
Proof.
- unfold slot_bounded, index_valid. auto.
+ unfold slot_within_bounds, index_valid. auto.
Qed.
Lemma index_arg_valid:
forall ofs ty,
- slot_bounded f (Outgoing ofs ty) ->
+ slot_within_bounds f b (Outgoing ofs ty) ->
index_valid (FI_arg ofs ty).
Proof.
- unfold slot_bounded, index_valid, b. auto.
+ unfold slot_within_bounds, index_valid. auto.
Qed.
Lemma index_saved_int_valid:
@@ -280,10 +314,8 @@ Lemma offset_of_index_no_overflow:
Proof.
intros.
generalize (offset_of_index_valid idx H). intros [A B].
-(* omega falls flat on its face... *)
apply Int.signed_repr.
- split. apply Zle_trans with 24. compute; intro; discriminate.
- auto.
+ split. apply Zle_trans with 24; auto. compute; intro; discriminate.
assert (offset_of_index fe idx < fe_size fe).
generalize (typesize_pos (type_of_index idx)); intro. omega.
apply Zlt_succ_le.
@@ -295,26 +327,30 @@ Qed.
instructions, in case the offset is computed with [offset_of_index]. *)
Lemma exec_Mgetstack':
- forall sp parent idx ty c rs fr dst m v,
+ forall sp idx ty c rs fr dst m v,
index_valid idx ->
get_slot fr ty (offset_of_index fe idx) v ->
- Machabstr.exec_instrs tge tf sp parent
- (Mgetstack (Int.repr (offset_of_index fe idx)) ty dst :: c) rs fr m
- E0 c (rs#dst <- v) fr m.
+ step tge
+ (State stack tf sp
+ (Mgetstack (Int.repr (offset_of_index fe idx)) ty dst :: c)
+ rs fr m)
+ E0 (State stack tf sp c (rs#dst <- v) fr m).
Proof.
- intros. apply Machabstr.exec_one. apply Machabstr.exec_Mgetstack.
+ intros. apply exec_Mgetstack.
rewrite offset_of_index_no_overflow. auto. auto.
Qed.
Lemma exec_Msetstack':
- forall sp parent idx ty c rs fr src m fr',
+ forall sp idx ty c rs fr src m fr',
index_valid idx ->
set_slot fr ty (offset_of_index fe idx) (rs src) fr' ->
- Machabstr.exec_instrs tge tf sp parent
- (Msetstack src (Int.repr (offset_of_index fe idx)) ty :: c) rs fr m
- E0 c rs fr' m.
+ step tge
+ (State stack tf sp
+ (Msetstack src (Int.repr (offset_of_index fe idx)) ty :: c)
+ rs fr m)
+ E0 (State stack tf sp c rs fr' m).
Proof.
- intros. apply Machabstr.exec_one. apply Machabstr.exec_Msetstack.
+ intros. apply exec_Msetstack.
rewrite offset_of_index_no_overflow. auto. auto.
Qed.
@@ -323,44 +359,42 @@ Qed.
function. *)
Definition index_val (idx: frame_index) (fr: frame) :=
- load_contents (mem_type (type_of_index idx))
- fr.(contents)
- (fr.(low) + offset_of_index fe idx).
+ fr.(fr_contents) (type_of_index idx) (fr.(fr_low) + offset_of_index fe idx).
Lemma get_slot_index:
forall fr idx ty v,
index_valid idx ->
- fr.(low) = - fe.(fe_size) ->
+ fr.(fr_low) = -fe.(fe_size) ->
ty = type_of_index idx ->
v = index_val idx fr ->
get_slot fr ty (offset_of_index fe idx) v.
Proof.
intros. subst v; subst ty.
generalize (offset_of_index_valid idx H); intros [A B].
- unfold index_val. apply get_slot_intro. omega.
- rewrite H0. omega. auto.
+ rewrite <- typesize_typesize in B.
+ unfold index_val. apply get_slot_intro; auto.
+ rewrite H0. omega.
Qed.
Lemma set_slot_index:
forall fr idx v,
index_valid idx ->
- fr.(high) = 0 ->
- fr.(low) = - fe.(fe_size) ->
+ fr.(fr_low) = -fe.(fe_size) ->
exists fr', set_slot fr (type_of_index idx) (offset_of_index fe idx) v fr'.
Proof.
intros.
generalize (offset_of_index_valid idx H); intros [A B].
- apply set_slot_ok. auto. omega. rewrite H1; omega.
+ apply set_slot_ok; auto. rewrite H0. omega.
Qed.
(** Alternate ``good variable'' properties for [get_slot] and [set_slot]. *)
+
Lemma slot_iss:
forall fr idx v fr',
set_slot fr (type_of_index idx) (offset_of_index fe idx) v fr' ->
index_val idx fr' = v.
Proof.
- intros. inversion H. subst ofs ty.
- unfold index_val; simpl. apply load_store_contents_same.
+ intros. exploit slot_gss; eauto. intro. inv H0. auto.
Qed.
Lemma slot_iso:
@@ -371,19 +405,20 @@ Lemma slot_iso:
index_val idx' fr' = index_val idx' fr.
Proof.
intros. generalize (offset_of_index_disj idx idx' H1 H2 H0). intro.
- unfold index_val. inversion H. subst ofs ty. simpl.
- apply load_store_contents_other.
- repeat rewrite size_mem_type. omega.
+ inv H. unfold index_val. simpl fr_low. apply frame_update_gso.
+ omega.
Qed.
(** * Agreement between location sets and Mach environments *)
-(** The following [agree] predicate expresses semantic agreement between
- a location set on the Linear side and, on the Mach side,
- a register set, plus the current and parent frames, plus the register
- set [rs0] at function entry. *)
+(** The following [agree] predicate expresses semantic agreement between:
+- on the Linear side, the current location set [ls] and the location
+ set at function entry [ls0];
+- on the Mach side, a register set [rs] plus the current and parent frames
+ [fr] and [parent].
+*)
-Record agree (ls: locset) (rs: regset) (fr parent: frame) (rs0: regset) : Prop :=
+Record agree (ls: locset) (rs: regset) (fr parent: frame) (ls0: locset) : Prop :=
mk_agree {
(** Machine registers have the same values on the Linear and Mach sides. *)
agree_reg:
@@ -393,25 +428,22 @@ Record agree (ls: locset) (rs: regset) (fr parent: frame) (rs0: regset) : Prop :
have the same values they had at function entry. In other terms,
these registers are never assigned. *)
agree_unused_reg:
- forall r, ~(mreg_bounded f r) -> rs r = rs0 r;
+ forall r, ~(mreg_within_bounds b r) -> rs r = ls0 (R r);
- (** The bounds of the current frame are [[- fe.(fe_size), 0]]. *)
- agree_high:
- fr.(high) = 0;
+ (** The low bound of the current frame is [- fe.(fe_size)]. *)
agree_size:
- fr.(low) = - fe.(fe_size);
+ fr.(fr_low) = -fe.(fe_size);
(** Local and outgoing stack slots (on the Linear side) have
the same values as the one loaded from the current Mach frame
at the corresponding offsets. *)
-
agree_locals:
forall ofs ty,
- slot_bounded f (Local ofs ty) ->
+ slot_within_bounds f b (Local ofs ty) ->
ls (S (Local ofs ty)) = index_val (FI_local ofs ty) fr;
agree_outgoing:
forall ofs ty,
- slot_bounded f (Outgoing ofs ty) ->
+ slot_within_bounds f b (Outgoing ofs ty) ->
ls (S (Outgoing ofs ty)) = index_val (FI_arg ofs ty) fr;
(** Incoming stack slots (on the Linear side) have
@@ -419,7 +451,7 @@ Record agree (ls: locset) (rs: regset) (fr parent: frame) (rs0: regset) : Prop :
at the corresponding offsets. *)
agree_incoming:
forall ofs ty,
- slot_bounded f (Incoming ofs ty) ->
+ slot_within_bounds f b (Incoming ofs ty) ->
get_slot parent ty (Int.signed (Int.repr (4 * ofs))) (ls (S (Incoming ofs ty)));
(** The areas of the frame reserved for saving used callee-save
@@ -429,35 +461,33 @@ Record agree (ls: locset) (rs: regset) (fr parent: frame) (rs0: regset) : Prop :
forall r,
In r int_callee_save_regs ->
index_int_callee_save r < b.(bound_int_callee_save) ->
- index_val (FI_saved_int (index_int_callee_save r)) fr = rs0 r;
+ index_val (FI_saved_int (index_int_callee_save r)) fr = ls0 (R r);
agree_saved_float:
forall r,
In r float_callee_save_regs ->
index_float_callee_save r < b.(bound_float_callee_save) ->
- index_val (FI_saved_float (index_float_callee_save r)) fr = rs0 r
+ index_val (FI_saved_float (index_float_callee_save r)) fr = ls0 (R r)
}.
-Hint Resolve agree_reg agree_unused_reg agree_size agree_high
+Hint Resolve agree_reg agree_unused_reg agree_size
agree_locals agree_outgoing agree_incoming
agree_saved_int agree_saved_float: stacking.
(** Values of registers and register lists. *)
Lemma agree_eval_reg:
- forall ls rs fr parent rs0 r,
- agree ls rs fr parent rs0 -> rs r = ls (R r).
+ forall ls rs fr parent ls0 r,
+ agree ls rs fr parent ls0 -> rs r = ls (R r).
Proof.
intros. symmetry. eauto with stacking.
Qed.
Lemma agree_eval_regs:
- forall ls rs fr parent rs0 rl,
- agree ls rs fr parent rs0 -> rs##rl = LTL.reglist rl ls.
+ forall ls rs fr parent ls0 rl,
+ agree ls rs fr parent ls0 -> rs##rl = reglist ls rl.
Proof.
induction rl; simpl; intros.
- auto. apply (f_equal2 (@cons val)).
- eapply agree_eval_reg; eauto.
- auto.
+ auto. f_equal. eapply agree_eval_reg; eauto. auto.
Qed.
Hint Resolve agree_eval_reg agree_eval_regs: stacking.
@@ -466,10 +496,10 @@ Hint Resolve agree_eval_reg agree_eval_regs: stacking.
of machine registers, of local slots, of outgoing slots. *)
Lemma agree_set_reg:
- forall ls rs fr parent rs0 r v,
- agree ls rs fr parent rs0 ->
- mreg_bounded f r ->
- agree (Locmap.set (R r) v ls) (Regmap.set r v rs) fr parent rs0.
+ forall ls rs fr parent ls0 r v,
+ agree ls rs fr parent ls0 ->
+ mreg_within_bounds b r ->
+ agree (Locmap.set (R r) v ls) (Regmap.set r v rs) fr parent ls0.
Proof.
intros. constructor; eauto with stacking.
intros. case (mreg_eq r r0); intro.
@@ -484,25 +514,22 @@ Proof.
Qed.
Lemma agree_set_local:
- forall ls rs fr parent rs0 v ofs ty,
- agree ls rs fr parent rs0 ->
- slot_bounded f (Local ofs ty) ->
+ forall ls rs fr parent ls0 v ofs ty,
+ agree ls rs fr parent ls0 ->
+ slot_within_bounds f b (Local ofs ty) ->
exists fr',
set_slot fr ty (offset_of_index fe (FI_local ofs ty)) v fr' /\
- agree (Locmap.set (S (Local ofs ty)) v ls) rs fr' parent rs0.
+ agree (Locmap.set (S (Local ofs ty)) v ls) rs fr' parent ls0.
Proof.
intros.
generalize (set_slot_index fr _ v (index_local_valid _ _ H0)
- (agree_high _ _ _ _ _ H)
(agree_size _ _ _ _ _ H)).
intros [fr' SET].
exists fr'. split. auto. constructor; eauto with stacking.
(* agree_reg *)
intros. rewrite Locmap.gso. eauto with stacking. red; auto.
- (* agree_high *)
- inversion SET. simpl high. eauto with stacking.
(* agree_size *)
- inversion SET. simpl low. eauto with stacking.
+ inversion SET. rewrite H3; simpl fr_low. eauto with stacking.
(* agree_local *)
intros. case (slot_eq (Local ofs ty) (Local ofs0 ty0)); intro.
rewrite <- e. rewrite Locmap.gss.
@@ -517,7 +544,7 @@ Proof.
(* agree_outgoing *)
intros. rewrite Locmap.gso. transitivity (index_val (FI_arg ofs0 ty0) fr).
eauto with stacking. symmetry. eapply slot_iso; eauto.
- red; auto. red; auto.
+ red; auto. red; auto.
(* agree_incoming *)
intros. rewrite Locmap.gso. eauto with stacking. red. auto.
(* agree_saved_int *)
@@ -529,30 +556,27 @@ Proof.
Qed.
Lemma agree_set_outgoing:
- forall ls rs fr parent rs0 v ofs ty,
- agree ls rs fr parent rs0 ->
- slot_bounded f (Outgoing ofs ty) ->
+ forall ls rs fr parent ls0 v ofs ty,
+ agree ls rs fr parent ls0 ->
+ slot_within_bounds f b (Outgoing ofs ty) ->
exists fr',
set_slot fr ty (offset_of_index fe (FI_arg ofs ty)) v fr' /\
- agree (Locmap.set (S (Outgoing ofs ty)) v ls) rs fr' parent rs0.
+ agree (Locmap.set (S (Outgoing ofs ty)) v ls) rs fr' parent ls0.
Proof.
intros.
generalize (set_slot_index fr _ v (index_arg_valid _ _ H0)
- (agree_high _ _ _ _ _ H)
(agree_size _ _ _ _ _ H)).
intros [fr' SET].
exists fr'. split. exact SET. constructor; eauto with stacking.
(* agree_reg *)
intros. rewrite Locmap.gso. eauto with stacking. red; auto.
- (* agree_high *)
- inversion SET. simpl high. eauto with stacking.
(* agree_size *)
- inversion SET. simpl low. eauto with stacking.
+ inversion SET. subst fr'; simpl fr_low. eauto with stacking.
(* agree_local *)
intros. rewrite Locmap.gso.
transitivity (index_val (FI_local ofs0 ty0) fr).
eauto with stacking. symmetry. eapply slot_iso; eauto.
- red; auto. red; auto.
+ red; auto. red; auto.
(* agree_outgoing *)
intros. unfold Locmap.set.
case (Loc.eq (S (Outgoing ofs ty)) (S (Outgoing ofs0 ty0))); intro.
@@ -562,18 +586,12 @@ Proof.
congruence. congruence.
(* overlapping locations *)
caseEq (Loc.overlap (S (Outgoing ofs ty)) (S (Outgoing ofs0 ty0))); intros.
- inversion SET. subst ofs1 ty1.
- unfold index_val, type_of_index, offset_of_index.
- set (ofs4 := 4 * ofs). set (ofs04 := 4 * ofs0). simpl.
- unfold ofs4, ofs04. symmetry.
- case (zeq ofs ofs0); intro.
- subst ofs0. apply load_store_contents_mismatch.
+ inv SET. unfold index_val, type_of_index, offset_of_index.
+ destruct (zeq ofs ofs0).
+ subst ofs0. symmetry. apply frame_update_mismatch.
destruct ty; destruct ty0; simpl; congruence.
- generalize (Loc.overlap_not_diff _ _ H2). intro. simpl in H4.
- apply load_store_contents_overlap.
- omega.
- rewrite size_mem_type. omega.
- rewrite size_mem_type. omega.
+ generalize (Loc.overlap_not_diff _ _ H2). intro. simpl in H5.
+ simpl fr_low. symmetry. apply frame_update_overlap. omega. omega. omega.
(* different locations *)
transitivity (index_val (FI_arg ofs0 ty0) fr).
eauto with stacking.
@@ -588,17 +606,17 @@ Proof.
intros. rewrite <- (agree_saved_float _ _ _ _ _ H r H1 H2).
eapply slot_iso; eauto with stacking. red; auto.
Qed.
-
+(*
Lemma agree_return_regs:
- forall ls rs fr parent rs0 ls' rs',
- agree ls rs fr parent rs0 ->
+ forall ls rs fr parent ls0 ls' rs',
+ agree ls rs fr parent ls0 ->
(forall r,
In (R r) temporaries \/ In (R r) destroyed_at_call ->
rs' r = ls' (R r)) ->
(forall r,
In r int_callee_save_regs \/ In r float_callee_save_regs ->
rs' r = rs r) ->
- agree (LTL.return_regs ls ls') rs' fr parent rs0.
+ agree (LTL.return_regs ls ls') rs' fr parent ls0.
Proof.
intros. constructor; unfold LTL.return_regs; eauto with stacking.
(* agree_reg *)
@@ -610,12 +628,117 @@ Proof.
generalize (register_classification r); tauto.
(* agree_unused_reg *)
intros. rewrite H1. eauto with stacking.
- generalize H2; unfold mreg_bounded; case (mreg_type r); intro.
+ generalize H2; unfold mreg_within_bounds; case (mreg_type r); intro.
left. apply index_int_callee_save_pos2.
- generalize (bound_int_callee_save_pos f); intro. omega.
+ generalize (bound_int_callee_save_pos b); intro. omega.
right. apply index_float_callee_save_pos2.
- generalize (bound_float_callee_save_pos f); intro. omega.
+ generalize (bound_float_callee_save_pos b); intro. omega.
Qed.
+*)
+
+Lemma agree_return_regs:
+ forall ls rs fr parent ls0 rs',
+ agree ls rs fr parent ls0 ->
+ (forall r,
+ ~In r int_callee_save_regs -> ~In r float_callee_save_regs ->
+ rs' r = rs r) ->
+ (forall r,
+ In r int_callee_save_regs \/ In r float_callee_save_regs ->
+ rs' r = ls0 (R r)) ->
+ (forall r, LTL.return_regs ls0 ls (R r) = rs' r).
+Proof.
+ intros; unfold LTL.return_regs.
+ case (In_dec Loc.eq (R r) temporaries); intro.
+ rewrite H0. eapply agree_reg; eauto.
+ apply int_callee_save_not_destroyed; auto.
+ apply float_callee_save_not_destroyed; auto.
+ case (In_dec Loc.eq (R r) destroyed_at_call); intro.
+ rewrite H0. eapply agree_reg; eauto.
+ apply int_callee_save_not_destroyed; auto.
+ apply float_callee_save_not_destroyed; auto.
+ symmetry; apply H1.
+ generalize (register_classification r); tauto.
+Qed.
+
+(** Agreement over callee-save registers and stack locations *)
+
+Definition agree_callee_save (ls1 ls2: locset) : Prop :=
+ forall l,
+ match l with
+ | R r => In r int_callee_save_regs \/ In r float_callee_save_regs
+ | S s => True
+ end ->
+ ls2 l = ls1 l.
+
+Remark mreg_not_within_bounds:
+ forall r,
+ ~mreg_within_bounds b r -> In r int_callee_save_regs \/ In r float_callee_save_regs.
+Proof.
+ intro r; unfold mreg_within_bounds.
+ destruct (mreg_type r); intro.
+ left. apply index_int_callee_save_pos2.
+ generalize (bound_int_callee_save_pos b). omega.
+ right. apply index_float_callee_save_pos2.
+ generalize (bound_float_callee_save_pos b). omega.
+Qed.
+
+Lemma agree_callee_save_agree:
+ forall ls rs fr parent ls1 ls2,
+ agree ls rs fr parent ls1 ->
+ agree_callee_save ls1 ls2 ->
+ agree ls rs fr parent ls2.
+Proof.
+ intros. inv H. constructor; auto.
+ intros. rewrite agree_unused_reg0; auto.
+ symmetry. apply H0. apply mreg_not_within_bounds; auto.
+ intros. rewrite (H0 (R r)); auto.
+ intros. rewrite (H0 (R r)); auto.
+Qed.
+
+Lemma agree_callee_save_return_regs:
+ forall ls1 ls2,
+ agree_callee_save (LTL.return_regs ls1 ls2) ls1.
+Proof.
+ intros; red; intros.
+ unfold LTL.return_regs. destruct l; auto.
+ generalize (int_callee_save_not_destroyed m); intro.
+ generalize (float_callee_save_not_destroyed m); intro.
+ destruct (In_dec Loc.eq (R m) temporaries). tauto.
+ destruct (In_dec Loc.eq (R m) destroyed_at_call). tauto.
+ auto.
+Qed.
+
+Lemma agree_callee_save_set_result:
+ forall ls1 ls2 v sg,
+ agree_callee_save ls1 ls2 ->
+ agree_callee_save (Locmap.set (R (Conventions.loc_result sg)) v ls1) ls2.
+Proof.
+ intros; red; intros. rewrite H; auto.
+ symmetry; apply Locmap.gso. destruct l; simpl; auto.
+ red; intro. subst m. elim (loc_result_not_callee_save _ H0).
+Qed.
+
+(** A variant of [agree] used for return frames. *)
+
+Definition agree_frame (ls: locset) (fr parent: frame) (ls0: locset) : Prop :=
+ exists rs, agree ls rs fr parent ls0.
+
+Lemma agree_frame_agree:
+ forall ls1 ls2 rs fr parent ls0,
+ agree_frame ls1 fr parent ls0 ->
+ agree_callee_save ls2 ls1 ->
+ (forall r, rs r = ls2 (R r)) ->
+ agree ls2 rs fr parent ls0.
+Proof.
+ intros. destruct H as [rs' AG]. inv AG.
+ constructor; auto.
+ intros. rewrite <- agree_unused_reg0; auto.
+ rewrite <- agree_reg0. rewrite H1. symmetry; apply H0.
+ apply mreg_not_within_bounds; auto.
+ intros. rewrite <- H0; auto.
+ intros. rewrite <- H0; auto.
+ intros. rewrite <- H0; auto.
+Qed.
(** * Correctness of saving and restoring of callee-save registers *)
@@ -624,87 +747,100 @@ Qed.
the register save areas of the current frame do contain the
values of the callee-save registers used by the function. *)
-Lemma save_int_callee_save_correct_rec:
- forall l k sp parent rs fr m,
- incl l int_callee_save_regs ->
+Section SAVE_CALLEE_SAVE.
+
+Variable bound: frame_env -> Z.
+Variable number: mreg -> Z.
+Variable mkindex: Z -> frame_index.
+Variable ty: typ.
+Variable sp: val.
+Variable csregs: list mreg.
+Hypothesis number_inj:
+ forall r1 r2, In r1 csregs -> In r2 csregs -> r1 <> r2 -> number r1 <> number r2.
+Hypothesis mkindex_valid:
+ forall r, In r csregs -> number r < bound fe -> index_valid (mkindex (number r)).
+Hypothesis mkindex_typ:
+ forall z, type_of_index (mkindex z) = ty.
+Hypothesis mkindex_inj:
+ forall z1 z2, z1 <> z2 -> mkindex z1 <> mkindex z2.
+Hypothesis mkindex_diff:
+ forall r idx,
+ idx <> mkindex (number r) -> index_diff (mkindex (number r)) idx.
+
+Lemma save_callee_save_regs_correct:
+ forall l k rs fr m,
+ incl l csregs ->
list_norepet l ->
- fr.(high) = 0 ->
- fr.(low) = -fe.(fe_size) ->
+ fr.(fr_low) = -fe.(fe_size) ->
exists fr',
- Machabstr.exec_instrs tge tf sp parent
- (List.fold_right (save_int_callee_save fe) k l) rs fr m
- E0 k rs fr' m
- /\ fr'.(high) = 0
- /\ fr'.(low) = -fe.(fe_size)
+ star step tge
+ (State stack tf sp
+ (save_callee_save_regs bound number mkindex ty fe l k) rs fr m)
+ E0 (State stack tf sp k rs fr' m)
+ /\ fr'.(fr_low) = - fe.(fe_size)
/\ (forall r,
- In r l -> index_int_callee_save r < bound_int_callee_save b ->
- index_val (FI_saved_int (index_int_callee_save r)) fr' = rs r)
+ In r l -> number r < bound fe ->
+ index_val (mkindex (number r)) fr' = rs r)
/\ (forall idx,
index_valid idx ->
(forall r,
- In r l -> index_int_callee_save r < bound_int_callee_save b ->
- idx <> FI_saved_int (index_int_callee_save r)) ->
+ In r l -> number r < bound fe -> idx <> mkindex (number r)) ->
index_val idx fr' = index_val idx fr).
Proof.
- induction l.
+ induction l; intros; simpl save_callee_save_regs.
(* base case *)
- intros. simpl fold_right. exists fr.
- split. apply Machabstr.exec_refl. split. auto. split. auto.
- split. intros. elim H3. auto.
+ exists fr. split. apply star_refl. split. auto.
+ split. intros. elim H2. auto.
(* inductive case *)
- intros. simpl fold_right.
- set (k1 := fold_right (save_int_callee_save fe) k l) in *.
- assert (R1: incl l int_callee_save_regs). eauto with coqlib.
+ set (k1 := save_callee_save_regs bound number mkindex ty fe l k).
+ assert (R1: incl l csregs). eauto with coqlib.
assert (R2: list_norepet l). inversion H0; auto.
- unfold save_int_callee_save.
- case (zlt (index_int_callee_save a) (fe_num_int_callee_save fe));
- intro;
- unfold fe_num_int_callee_save, fe, make_env in z.
+ unfold save_callee_save_reg.
+ destruct (zlt (number a) (bound fe)).
(* a store takes place *)
- assert (IDX: index_valid (FI_saved_int (index_int_callee_save a))).
- apply index_saved_int_valid. eauto with coqlib. auto.
- generalize (set_slot_index _ _ (rs a) IDX H1 H2).
+ assert (VALID: index_valid (mkindex (number a))).
+ apply mkindex_valid. auto with coqlib. auto.
+ exploit set_slot_index; eauto.
intros [fr1 SET].
- assert (R3: high fr1 = 0). inversion SET. simpl high. auto.
- assert (R4: low fr1 = -fe_size fe). inversion SET. simpl low. auto.
- generalize (IHl k sp parent rs fr1 m R1 R2 R3 R4).
- intros [fr' [A [B [C [D E]]]]].
- exists fr'.
- split. eapply Machabstr.exec_trans. apply exec_Msetstack'; eauto with stacking.
+ exploit (IHl k rs fr1 m); auto. inv SET; auto.
+ fold k1. intros [fr' [A [B [C D]]]].
+ exists fr'.
+ split. eapply star_left.
+ apply exec_Msetstack'; eauto with stacking. rewrite <- (mkindex_typ (number a)). eauto.
eexact A. traceEq.
- split. auto.
- split. auto.
- split. intros. elim H3; intros. subst r.
- rewrite E. eapply slot_iss; eauto. auto.
- intros. decEq. apply index_int_callee_save_inj; auto with coqlib.
+ split. auto.
+ split. intros. elim H2; intros. subst r.
+ rewrite D. eapply slot_iss; eauto.
+ apply mkindex_valid; auto.
+ intros. apply mkindex_inj. apply number_inj; auto with coqlib.
inversion H0. red; intro; subst r; contradiction.
- apply D; auto.
+ apply C; auto.
intros. transitivity (index_val idx fr1).
- apply E; auto.
- intros. apply H4; eauto with coqlib.
- eapply slot_iso; eauto.
- destruct idx; simpl; auto.
- generalize (H4 a (in_eq _ _) z). congruence.
- (* no store takes place *)
- generalize (IHl k sp parent rs fr m R1 R2 H1 H2).
- intros [fr' [A [B [C [D E]]]]].
- exists fr'. split. exact A. split. exact B. split. exact C.
- split. intros. elim H3; intros. subst r. omegaContradiction.
apply D; auto.
- intros. apply E; auto.
- intros. apply H4; auto with coqlib.
-Qed.
+ intros. apply H3; eauto with coqlib.
+ eapply slot_iso; eauto.
+ apply mkindex_diff. apply H3. auto with coqlib.
+ auto.
+ (* no store takes place *)
+ exploit (IHl k rs fr m); auto. intros [fr' [A [B [C D]]]].
+ exists fr'. split. exact A. split. exact B.
+ split. intros. elim H2; intros. subst r. omegaContradiction.
+ apply C; auto.
+ intros. apply D; auto.
+ intros. apply H3; auto with coqlib.
+Qed.
-Lemma save_int_callee_save_correct:
- forall k sp parent rs fr m,
- fr.(high) = 0 ->
- fr.(low) = -fe.(fe_size) ->
+End SAVE_CALLEE_SAVE.
+
+Lemma save_callee_save_int_correct:
+ forall k sp rs fr m,
+ fr.(fr_low) = - fe.(fe_size) ->
exists fr',
- Machabstr.exec_instrs tge tf sp parent
- (List.fold_right (save_int_callee_save fe) k int_callee_save_regs) rs fr m
- E0 k rs fr' m
- /\ fr'.(high) = 0
- /\ fr'.(low) = -fe.(fe_size)
+ star step tge
+ (State stack tf sp
+ (save_callee_save_int fe k) rs fr m)
+ E0 (State stack tf sp k rs fr' m)
+ /\ fr'.(fr_low) = - fe.(fe_size)
/\ (forall r,
In r int_callee_save_regs ->
index_int_callee_save r < bound_int_callee_save b ->
@@ -714,98 +850,30 @@ Lemma save_int_callee_save_correct:
match idx with FI_saved_int _ => False | _ => True end ->
index_val idx fr' = index_val idx fr).
Proof.
- intros.
- generalize (save_int_callee_save_correct_rec
- int_callee_save_regs k sp parent rs fr m
- (incl_refl _) int_callee_save_norepet H H0).
- intros [fr' [A [B [C [D E]]]]].
- exists fr'.
- split. assumption. split. assumption. split. assumption.
- split. apply D. intros. apply E. auto.
- intros. red; intros; subst idx. contradiction.
+ intros.
+ exploit (save_callee_save_regs_correct fe_num_int_callee_save index_int_callee_save FI_saved_int
+ Tint sp int_callee_save_regs).
+ exact index_int_callee_save_inj.
+ intros. red. split; auto. generalize (index_int_callee_save_pos r H0). omega.
+ auto.
+ intros; congruence.
+ intros until idx. destruct idx; simpl; auto. congruence.
+ apply incl_refl.
+ apply int_callee_save_norepet. eauto.
+ intros [fr' [A [B [C D]]]].
+ exists fr'; intuition. unfold save_callee_save_int; eauto.
+ apply D. auto. intros; subst idx. auto.
Qed.
-Lemma save_float_callee_save_correct_rec:
- forall l k sp parent rs fr m,
- incl l float_callee_save_regs ->
- list_norepet l ->
- fr.(high) = 0 ->
- fr.(low) = -fe.(fe_size) ->
- exists fr',
- Machabstr.exec_instrs tge tf sp parent
- (List.fold_right (save_float_callee_save fe) k l) rs fr m
- E0 k rs fr' m
- /\ fr'.(high) = 0
- /\ fr'.(low) = -fe.(fe_size)
- /\ (forall r,
- In r l -> index_float_callee_save r < bound_float_callee_save b ->
- index_val (FI_saved_float (index_float_callee_save r)) fr' = rs r)
- /\ (forall idx,
- index_valid idx ->
- (forall r,
- In r l -> index_float_callee_save r < bound_float_callee_save b ->
- idx <> FI_saved_float (index_float_callee_save r)) ->
- index_val idx fr' = index_val idx fr).
-Proof.
- induction l.
- (* base case *)
- intros. simpl fold_right. exists fr.
- split. apply Machabstr.exec_refl. split. auto. split. auto.
- split. intros. elim H3. auto.
- (* inductive case *)
- intros. simpl fold_right.
- set (k1 := fold_right (save_float_callee_save fe) k l) in *.
- assert (R1: incl l float_callee_save_regs). eauto with coqlib.
- assert (R2: list_norepet l). inversion H0; auto.
- unfold save_float_callee_save.
- case (zlt (index_float_callee_save a) (fe_num_float_callee_save fe));
- intro;
- unfold fe_num_float_callee_save, fe, make_env in z.
- (* a store takes place *)
- assert (IDX: index_valid (FI_saved_float (index_float_callee_save a))).
- apply index_saved_float_valid. eauto with coqlib. auto.
- generalize (set_slot_index _ _ (rs a) IDX H1 H2).
- intros [fr1 SET].
- assert (R3: high fr1 = 0). inversion SET. simpl high. auto.
- assert (R4: low fr1 = -fe_size fe). inversion SET. simpl low. auto.
- generalize (IHl k sp parent rs fr1 m R1 R2 R3 R4).
- intros [fr' [A [B [C [D E]]]]].
- exists fr'.
- split. eapply Machabstr.exec_trans. apply exec_Msetstack'; eauto with stacking.
- eexact A. traceEq.
- split. auto.
- split. auto.
- split. intros. elim H3; intros. subst r.
- rewrite E. eapply slot_iss; eauto. auto.
- intros. decEq. apply index_float_callee_save_inj; auto with coqlib.
- inversion H0. red; intro; subst r; contradiction.
- apply D; auto.
- intros. transitivity (index_val idx fr1).
- apply E; auto.
- intros. apply H4; eauto with coqlib.
- eapply slot_iso; eauto.
- destruct idx; simpl; auto.
- generalize (H4 a (in_eq _ _) z). congruence.
- (* no store takes place *)
- generalize (IHl k sp parent rs fr m R1 R2 H1 H2).
- intros [fr' [A [B [C [D E]]]]].
- exists fr'. split. exact A. split. exact B. split. exact C.
- split. intros. elim H3; intros. subst r. omegaContradiction.
- apply D; auto.
- intros. apply E; auto.
- intros. apply H4; auto with coqlib.
-Qed.
-
-Lemma save_float_callee_save_correct:
- forall k sp parent rs fr m,
- fr.(high) = 0 ->
- fr.(low) = -fe.(fe_size) ->
+Lemma save_callee_save_float_correct:
+ forall k sp rs fr m,
+ fr.(fr_low) = - fe.(fe_size) ->
exists fr',
- Machabstr.exec_instrs tge tf sp parent
- (List.fold_right (save_float_callee_save fe) k float_callee_save_regs) rs fr m
- E0 k rs fr' m
- /\ fr'.(high) = 0
- /\ fr'.(low) = -fe.(fe_size)
+ star step tge
+ (State stack tf sp
+ (save_callee_save_float fe k) rs fr m)
+ E0 (State stack tf sp k rs fr' m)
+ /\ fr'.(fr_low) = - fe.(fe_size)
/\ (forall r,
In r float_callee_save_regs ->
index_float_callee_save r < bound_float_callee_save b ->
@@ -815,63 +883,59 @@ Lemma save_float_callee_save_correct:
match idx with FI_saved_float _ => False | _ => True end ->
index_val idx fr' = index_val idx fr).
Proof.
- intros.
- generalize (save_float_callee_save_correct_rec
- float_callee_save_regs k sp parent rs fr m
- (incl_refl _) float_callee_save_norepet H H0).
- intros [fr' [A [B [C [D E]]]]].
- exists fr'. split. assumption. split. assumption. split. assumption.
- split. apply D. intros. apply E. auto.
- intros. red; intros; subst idx. contradiction.
-Qed.
-
-Lemma index_val_init_frame:
- forall idx,
- index_valid idx ->
- index_val idx (init_frame tf) = Vundef.
-Proof.
- intros. unfold index_val, init_frame. simpl contents.
- apply load_contents_init.
+ intros.
+ exploit (save_callee_save_regs_correct fe_num_float_callee_save index_float_callee_save FI_saved_float
+ Tfloat sp float_callee_save_regs).
+ exact index_float_callee_save_inj.
+ intros. red. split; auto. generalize (index_float_callee_save_pos r H0). omega.
+ auto.
+ intros; congruence.
+ intros until idx. destruct idx; simpl; auto. congruence.
+ apply incl_refl.
+ apply float_callee_save_norepet. eauto.
+ intros [fr' [A [B [C D]]]].
+ exists fr'; intuition. unfold save_callee_save_float; eauto.
+ apply D. auto. intros; subst idx. auto.
Qed.
Lemma save_callee_save_correct:
- forall sp parent k rs fr m ls,
+ forall sp k rs fr m ls,
(forall r, rs r = ls (R r)) ->
(forall ofs ty,
- 6 <= ofs ->
- ofs + typesize ty <= size_arguments f.(fn_sig) ->
- get_slot parent ty (Int.signed (Int.repr (4 * ofs))) (ls (S (Outgoing ofs ty)))) ->
- high fr = 0 ->
- low fr = -fe.(fe_size) ->
+ 14 <= ofs ->
+ ofs + typesize ty <= size_arguments f.(Linear.fn_sig) ->
+ get_slot (parent_frame stack) ty (Int.signed (Int.repr (4 * ofs))) (ls (S (Outgoing ofs ty)))) ->
+ fr.(fr_low) = - fe.(fe_size) ->
(forall idx, index_valid idx -> index_val idx fr = Vundef) ->
exists fr',
- Machabstr.exec_instrs tge tf sp parent
- (save_callee_save fe k) rs fr m
- E0 k rs fr' m
- /\ agree (LTL.call_regs ls) rs fr' parent rs.
+ star step tge
+ (State stack tf sp (save_callee_save fe k) rs fr m)
+ E0 (State stack tf sp k rs fr' m)
+ /\ agree (LTL.call_regs ls) rs fr' (parent_frame stack) ls.
Proof.
intros. unfold save_callee_save.
- generalize (save_int_callee_save_correct
- (fold_right (save_float_callee_save fe) k float_callee_save_regs)
- sp parent rs fr m H1 H2).
- intros [fr1 [A1 [B1 [C1 [D1 E1]]]]].
- generalize (save_float_callee_save_correct k sp parent rs fr1 m B1 C1).
- intros [fr2 [A2 [B2 [C2 [D2 E2]]]]].
+ exploit save_callee_save_int_correct; eauto.
+ intros [fr1 [A1 [B1 [C1 D1]]]].
+ exploit save_callee_save_float_correct. eexact B1.
+ intros [fr2 [A2 [B2 [C2 D2]]]].
exists fr2.
- split. eapply Machabstr.exec_trans. eexact A1. eexact A2. traceEq.
+ split. eapply star_trans. eexact A1. eexact A2. traceEq.
constructor; unfold LTL.call_regs; auto.
(* agree_local *)
- intros. rewrite E2; auto with stacking.
- rewrite E1; auto with stacking.
+ intros. rewrite D2; auto with stacking.
+ rewrite D1; auto with stacking.
symmetry. auto with stacking.
(* agree_outgoing *)
- intros. rewrite E2; auto with stacking.
- rewrite E1; auto with stacking.
+ intros. rewrite D2; auto with stacking.
+ rewrite D1; auto with stacking.
symmetry. auto with stacking.
(* agree_incoming *)
- intros. simpl in H4. apply H0. tauto. tauto.
+ intros. simpl in H3. apply H0. tauto. tauto.
(* agree_saved_int *)
- intros. rewrite E2; auto with stacking.
+ intros. rewrite D2; auto with stacking.
+ rewrite C1; auto with stacking.
+ (* agree_saved_float *)
+ intros. rewrite C2; auto with stacking.
Qed.
(** The following lemmas show the correctness of the register reloading
@@ -879,49 +943,66 @@ Qed.
all callee-save registers contain the same values they had at
function entry. *)
-Lemma restore_int_callee_save_correct_rec:
- forall sp parent k fr m rs0 l ls rs,
- incl l int_callee_save_regs ->
+Section RESTORE_CALLEE_SAVE.
+
+Variable bound: frame_env -> Z.
+Variable number: mreg -> Z.
+Variable mkindex: Z -> frame_index.
+Variable ty: typ.
+Variable sp: val.
+Variable csregs: list mreg.
+Hypothesis mkindex_valid:
+ forall r, In r csregs -> number r < bound fe -> index_valid (mkindex (number r)).
+Hypothesis mkindex_typ:
+ forall z, type_of_index (mkindex z) = ty.
+Hypothesis number_within_bounds:
+ forall r, In r csregs ->
+ (number r < bound fe <-> mreg_within_bounds b r).
+Hypothesis mkindex_val:
+ forall ls rs fr ls0 r,
+ agree ls rs fr (parent_frame stack) ls0 -> In r csregs -> number r < bound fe ->
+ index_val (mkindex (number r)) fr = ls0 (R r).
+
+Lemma restore_callee_save_regs_correct:
+ forall k fr m ls0 l ls rs,
+ incl l csregs ->
list_norepet l ->
- agree ls rs fr parent rs0 ->
+ agree ls rs fr (parent_frame stack) ls0 ->
exists ls', exists rs',
- Machabstr.exec_instrs tge tf sp parent
- (List.fold_right (restore_int_callee_save fe) k l) rs fr m
- E0 k rs' fr m
- /\ (forall r, In r l -> rs' r = rs0 r)
+ star step tge
+ (State stack tf sp
+ (restore_callee_save_regs bound number mkindex ty fe l k) rs fr m)
+ E0 (State stack tf sp k rs' fr m)
+ /\ (forall r, In r l -> rs' r = ls0 (R r))
/\ (forall r, ~(In r l) -> rs' r = rs r)
- /\ agree ls' rs' fr parent rs0.
+ /\ agree ls' rs' fr (parent_frame stack) ls0.
Proof.
- induction l.
+ induction l; intros; simpl restore_callee_save_regs.
(* base case *)
- intros. simpl fold_right. exists ls. exists rs.
- split. apply Machabstr.exec_refl.
+ exists ls. exists rs.
+ split. apply star_refl.
split. intros. elim H2.
split. auto. auto.
(* inductive case *)
- intros. simpl fold_right.
- set (k1 := fold_right (restore_int_callee_save fe) k l) in *.
- assert (R0: In a int_callee_save_regs). apply H; auto with coqlib.
- assert (R1: incl l int_callee_save_regs). eauto with coqlib.
+ set (k1 := restore_callee_save_regs bound number mkindex ty fe l k).
+ assert (R0: In a csregs). apply H; auto with coqlib.
+ assert (R1: incl l csregs). eauto with coqlib.
assert (R2: list_norepet l). inversion H0; auto.
- unfold restore_int_callee_save.
- case (zlt (index_int_callee_save a) (fe_num_int_callee_save fe));
- intro;
- unfold fe_num_int_callee_save, fe, make_env in z.
- set (ls1 := Locmap.set (R a) (rs0 a) ls).
- set (rs1 := Regmap.set a (rs0 a) rs).
- assert (R3: agree ls1 rs1 fr parent rs0).
+ unfold restore_callee_save_reg.
+ destruct (zlt (number a) (bound fe)).
+ set (ls1 := Locmap.set (R a) (ls0 (R a)) ls).
+ set (rs1 := Regmap.set a (ls0 (R a)) rs).
+ assert (R3: agree ls1 rs1 fr (parent_frame stack) ls0).
unfold ls1, rs1. apply agree_set_reg. auto.
- red. rewrite int_callee_save_type. exact z.
- apply H. auto with coqlib.
+ rewrite <- number_within_bounds; auto.
generalize (IHl ls1 rs1 R1 R2 R3).
intros [ls' [rs' [A [B [C D]]]]].
- exists ls'. exists rs'.
- split. apply Machabstr.exec_trans with E0 k1 rs1 fr m E0.
+ exists ls'. exists rs'. split.
+ apply star_left with E0 (State stack tf sp k1 rs1 fr m) E0.
unfold rs1; apply exec_Mgetstack'; eauto with stacking.
apply get_slot_index; eauto with stacking.
- symmetry. eauto with stacking.
- eauto with stacking. traceEq.
+ symmetry. eapply mkindex_val; eauto.
+ auto. traceEq.
split. intros. elim H2; intros.
subst r. rewrite C. unfold rs1. apply Regmap.gss. inversion H0; auto.
auto.
@@ -934,127 +1015,82 @@ Proof.
exists ls'; exists rs'. split. assumption.
split. intros. elim H2; intros.
subst r. apply (agree_unused_reg _ _ _ _ _ D).
- unfold mreg_bounded. rewrite int_callee_save_type; auto.
- auto.
+ rewrite <- number_within_bounds. auto. omega. auto.
split. intros. simpl in H2. apply C. tauto.
assumption.
Qed.
+End RESTORE_CALLEE_SAVE.
+
Lemma restore_int_callee_save_correct:
- forall sp parent k fr m rs0 ls rs,
- agree ls rs fr parent rs0 ->
+ forall sp k fr m ls0 ls rs,
+ agree ls rs fr (parent_frame stack) ls0 ->
exists ls', exists rs',
- Machabstr.exec_instrs tge tf sp parent
- (List.fold_right (restore_int_callee_save fe) k int_callee_save_regs) rs fr m
- E0 k rs' fr m
- /\ (forall r, In r int_callee_save_regs -> rs' r = rs0 r)
+ star step tge
+ (State stack tf sp
+ (restore_callee_save_int fe k) rs fr m)
+ E0 (State stack tf sp k rs' fr m)
+ /\ (forall r, In r int_callee_save_regs -> rs' r = ls0 (R r))
/\ (forall r, ~(In r int_callee_save_regs) -> rs' r = rs r)
- /\ agree ls' rs' fr parent rs0.
+ /\ agree ls' rs' fr (parent_frame stack) ls0.
Proof.
- intros. apply restore_int_callee_save_correct_rec with ls.
- apply incl_refl. apply int_callee_save_norepet. auto.
-Qed.
-
-Lemma restore_float_callee_save_correct_rec:
- forall sp parent k fr m rs0 l ls rs,
- incl l float_callee_save_regs ->
- list_norepet l ->
- agree ls rs fr parent rs0 ->
- exists ls', exists rs',
- Machabstr.exec_instrs tge tf sp parent
- (List.fold_right (restore_float_callee_save fe) k l) rs fr m
- E0 k rs' fr m
- /\ (forall r, In r l -> rs' r = rs0 r)
- /\ (forall r, ~(In r l) -> rs' r = rs r)
- /\ agree ls' rs' fr parent rs0.
-Proof.
- induction l.
- (* base case *)
- intros. simpl fold_right. exists ls. exists rs.
- split. apply Machabstr.exec_refl.
- split. intros. elim H2.
- split. auto. auto.
- (* inductive case *)
- intros. simpl fold_right.
- set (k1 := fold_right (restore_float_callee_save fe) k l) in *.
- assert (R0: In a float_callee_save_regs). apply H; auto with coqlib.
- assert (R1: incl l float_callee_save_regs). eauto with coqlib.
- assert (R2: list_norepet l). inversion H0; auto.
- unfold restore_float_callee_save.
- case (zlt (index_float_callee_save a) (fe_num_float_callee_save fe));
- intro;
- unfold fe_num_float_callee_save, fe, make_env in z.
- set (ls1 := Locmap.set (R a) (rs0 a) ls).
- set (rs1 := Regmap.set a (rs0 a) rs).
- assert (R3: agree ls1 rs1 fr parent rs0).
- unfold ls1, rs1. apply agree_set_reg. auto.
- red. rewrite float_callee_save_type. exact z.
- apply H. auto with coqlib.
- generalize (IHl ls1 rs1 R1 R2 R3).
- intros [ls' [rs' [A [B [C D]]]]].
- exists ls'. exists rs'.
- split. apply Machabstr.exec_trans with E0 k1 rs1 fr m E0.
- unfold rs1; apply exec_Mgetstack'; eauto with stacking.
- apply get_slot_index; eauto with stacking.
- symmetry. eauto with stacking.
- exact A. traceEq.
- split. intros. elim H2; intros.
- subst r. rewrite C. unfold rs1. apply Regmap.gss. inversion H0; auto.
+ intros. unfold restore_callee_save_int.
+ apply restore_callee_save_regs_correct with int_callee_save_regs ls.
+ intros; simpl. split; auto. generalize (index_int_callee_save_pos r H0). omega.
auto.
- split. intros. simpl in H2. rewrite C. unfold rs1. apply Regmap.gso.
- apply sym_not_eq; tauto. tauto.
- assumption.
- (* no load takes place *)
- generalize (IHl ls rs R1 R2 H1).
- intros [ls' [rs' [A [B [C D]]]]].
- exists ls'; exists rs'. split. assumption.
- split. intros. elim H2; intros.
- subst r. apply (agree_unused_reg _ _ _ _ _ D).
- unfold mreg_bounded. rewrite float_callee_save_type; auto.
+ intros. unfold mreg_within_bounds.
+ rewrite (int_callee_save_type r H0). tauto.
+ eauto with stacking.
+ apply incl_refl.
+ apply int_callee_save_norepet.
auto.
- split. intros. simpl in H2. apply C. tauto.
- assumption.
Qed.
Lemma restore_float_callee_save_correct:
- forall sp parent k fr m rs0 ls rs,
- agree ls rs fr parent rs0 ->
+ forall sp k fr m ls0 ls rs,
+ agree ls rs fr (parent_frame stack) ls0 ->
exists ls', exists rs',
- Machabstr.exec_instrs tge tf sp parent
- (List.fold_right (restore_float_callee_save fe) k float_callee_save_regs) rs fr m
- E0 k rs' fr m
- /\ (forall r, In r float_callee_save_regs -> rs' r = rs0 r)
+ star step tge
+ (State stack tf sp
+ (restore_callee_save_float fe k) rs fr m)
+ E0 (State stack tf sp k rs' fr m)
+ /\ (forall r, In r float_callee_save_regs -> rs' r = ls0 (R r))
/\ (forall r, ~(In r float_callee_save_regs) -> rs' r = rs r)
- /\ agree ls' rs' fr parent rs0.
+ /\ agree ls' rs' fr (parent_frame stack) ls0.
Proof.
- intros. apply restore_float_callee_save_correct_rec with ls.
- apply incl_refl. apply float_callee_save_norepet. auto.
+ intros. unfold restore_callee_save_float.
+ apply restore_callee_save_regs_correct with float_callee_save_regs ls.
+ intros; simpl. split; auto. generalize (index_float_callee_save_pos r H0). omega.
+ auto.
+ intros. unfold mreg_within_bounds.
+ rewrite (float_callee_save_type r H0). tauto.
+ eauto with stacking.
+ apply incl_refl.
+ apply float_callee_save_norepet.
+ auto.
Qed.
Lemma restore_callee_save_correct:
- forall sp parent k fr m rs0 ls rs,
- agree ls rs fr parent rs0 ->
+ forall sp k fr m ls0 ls rs,
+ agree ls rs fr (parent_frame stack) ls0 ->
exists rs',
- Machabstr.exec_instrs tge tf sp parent
- (restore_callee_save fe k) rs fr m
- E0 k rs' fr m
+ star step tge
+ (State stack tf sp (restore_callee_save fe k) rs fr m)
+ E0 (State stack tf sp k rs' fr m)
/\ (forall r,
In r int_callee_save_regs \/ In r float_callee_save_regs ->
- rs' r = rs0 r)
+ rs' r = ls0 (R r))
/\ (forall r,
~(In r int_callee_save_regs) ->
~(In r float_callee_save_regs) ->
rs' r = rs r).
Proof.
intros. unfold restore_callee_save.
- generalize (restore_int_callee_save_correct sp parent
- (fold_right (restore_float_callee_save fe) k float_callee_save_regs)
- fr m rs0 ls rs H).
+ exploit restore_int_callee_save_correct; eauto.
intros [ls1 [rs1 [A [B [C D]]]]].
- generalize (restore_float_callee_save_correct sp parent
- k fr m rs0 ls1 rs1 D).
+ exploit restore_float_callee_save_correct. eexact D.
intros [ls2 [rs2 [P [Q [R S]]]]].
- exists rs2. split. eapply Machabstr.exec_trans. eexact A. eexact P. traceEq.
+ exists rs2. split. eapply star_trans. eexact A. eexact P. traceEq.
split. intros. elim H0; intros.
rewrite R. apply B. auto. apply list_disjoint_notin with int_callee_save_regs.
apply int_float_callee_save_disjoint. auto.
@@ -1083,12 +1119,12 @@ Remark find_label_save_callee_save:
forall fe lbl k,
Mach.find_label lbl (save_callee_save fe k) = Mach.find_label lbl k.
Proof.
- intros. unfold save_callee_save.
+ intros. unfold save_callee_save, save_callee_save_int, save_callee_save_float, save_callee_save_regs.
repeat rewrite find_label_fold_right. reflexivity.
- intros. unfold save_float_callee_save.
+ intros. unfold save_callee_save_reg.
case (zlt (index_float_callee_save x) (fe_num_float_callee_save fe));
intro; reflexivity.
- intros. unfold save_int_callee_save.
+ intros. unfold save_callee_save_reg.
case (zlt (index_int_callee_save x) (fe_num_int_callee_save fe));
intro; reflexivity.
Qed.
@@ -1097,12 +1133,12 @@ Remark find_label_restore_callee_save:
forall fe lbl k,
Mach.find_label lbl (restore_callee_save fe k) = Mach.find_label lbl k.
Proof.
- intros. unfold restore_callee_save.
+ intros. unfold restore_callee_save, restore_callee_save_int, restore_callee_save_float, restore_callee_save_regs.
repeat rewrite find_label_fold_right. reflexivity.
- intros. unfold restore_float_callee_save.
+ intros. unfold restore_callee_save_reg.
case (zlt (index_float_callee_save x) (fe_num_float_callee_save fe));
intro; reflexivity.
- intros. unfold restore_int_callee_save.
+ intros. unfold restore_callee_save_reg.
case (zlt (index_int_callee_save x) (fe_num_int_callee_save fe));
intro; reflexivity.
Qed.
@@ -1117,13 +1153,14 @@ Proof.
destruct a; unfold transl_instr; auto.
destruct s; simpl; auto.
destruct s; simpl; auto.
+ rewrite find_label_restore_callee_save. auto.
simpl. case (peq lbl l); intro. reflexivity. auto.
rewrite find_label_restore_callee_save. auto.
Qed.
Lemma transl_find_label:
forall f tf lbl c,
- transf_function f = Some tf ->
+ transf_function f = OK tf ->
Linear.find_label lbl f.(Linear.fn_code) = Some c ->
Mach.find_label lbl tf.(Mach.fn_code) =
Some (transl_code (make_env (function_bounds f)) c).
@@ -1143,32 +1180,11 @@ Lemma find_label_incl:
Proof.
induction c; simpl.
intros; discriminate.
- intro c'. case (is_label lbl a); intros.
+ intro c'. case (Linear.is_label lbl a); intros.
injection H; intro; subst c'. red; intros; auto with coqlib.
apply incl_tl. auto.
Qed.
-Lemma exec_instr_incl:
- forall f sp c1 ls1 m1 t c2 ls2 m2,
- Linear.exec_instr ge f sp c1 ls1 m1 t c2 ls2 m2 ->
- incl c1 f.(fn_code) ->
- incl c2 f.(fn_code).
-Proof.
- induction 1; intros; eauto with coqlib.
- eapply find_label_incl; eauto.
- eapply find_label_incl; eauto.
-Qed.
-
-Lemma exec_instrs_incl:
- forall f sp c1 ls1 m1 t c2 ls2 m2,
- Linear.exec_instrs ge f sp c1 ls1 m1 t c2 ls2 m2 ->
- incl c1 f.(fn_code) ->
- incl c2 f.(fn_code).
-Proof.
- induction 1; intros; auto.
- eapply exec_instr_incl; eauto.
-Qed.
-
(** Preservation / translation of global symbols and functions. *)
Lemma symbols_preserved:
@@ -1180,42 +1196,59 @@ Proof.
Qed.
Lemma functions_translated:
- forall f v,
+ forall v f,
Genv.find_funct ge v = Some f ->
exists tf,
- Genv.find_funct tge v = Some tf /\ transf_fundef f = Some tf.
-Proof.
- intros.
- generalize (Genv.find_funct_transf_partial transf_fundef TRANSF H).
- case (transf_fundef f).
- intros tf [A B]. exists tf. tauto.
- intros. tauto.
-Qed.
+ Genv.find_funct tge v = Some tf /\ transf_fundef f = OK tf.
+Proof
+ (Genv.find_funct_transf_partial transf_fundef TRANSF).
Lemma function_ptr_translated:
- forall f v,
+ forall v f,
Genv.find_funct_ptr ge v = Some f ->
exists tf,
- Genv.find_funct_ptr tge v = Some tf /\ transf_fundef f = Some tf.
-Proof.
- intros.
- generalize (Genv.find_funct_ptr_transf_partial transf_fundef TRANSF H).
- case (transf_fundef f).
- intros tf [A B]. exists tf. tauto.
- intros. tauto.
-Qed.
+ Genv.find_funct_ptr tge v = Some tf /\ transf_fundef f = OK tf.
+Proof
+ (Genv.find_funct_ptr_transf_partial transf_fundef TRANSF).
Lemma sig_preserved:
- forall f tf, transf_fundef f = Some tf -> Mach.funsig tf = Linear.funsig f.
+ forall f tf, transf_fundef f = OK tf -> Mach.funsig tf = Linear.funsig f.
Proof.
intros until tf; unfold transf_fundef, transf_partial_fundef.
destruct f. unfold transf_function.
- destruct (zlt (fn_stacksize f) 0). congruence.
- destruct (zlt (- Int.min_signed) (fe_size (make_env (function_bounds f)))). congruence.
- intros. inversion H; reflexivity.
+ destruct (zlt (Linear.fn_stacksize f) 0). simpl; congruence.
+ destruct (zlt (- Int.min_signed) (fe_size (make_env (function_bounds f)))). simpl; congruence.
+ unfold bind. intros. inversion H; reflexivity.
intro. inversion H. reflexivity.
Qed.
+Lemma find_function_translated:
+ forall f0 ls rs fr parent ls0 ros f,
+ agree f0 ls rs fr parent ls0 ->
+ Linear.find_function ge ros ls = Some f ->
+ exists tf,
+ find_function tge ros rs = Some tf /\ transf_fundef f = OK tf.
+Proof.
+ intros until f; intro AG.
+ destruct ros; simpl.
+ rewrite (agree_eval_reg _ _ _ _ _ _ m AG). intro.
+ apply functions_translated; auto.
+ rewrite symbols_preserved. destruct (Genv.find_symbol ge i); try congruence.
+ intro. apply function_ptr_translated; auto.
+Qed.
+
+Hypothesis wt_prog: wt_program prog.
+
+Lemma find_function_well_typed:
+ forall ros ls f,
+ Linear.find_function ge ros ls = Some f -> wt_fundef f.
+Proof.
+ intros until f; destruct ros; simpl; unfold ge.
+ intro. eapply Genv.find_funct_prop; eauto.
+ destruct (Genv.find_symbol (Genv.globalenv prog) i); try congruence.
+ intro. eapply Genv.find_funct_ptr_prop; eauto.
+Qed.
+
(** Correctness of stack pointer relocation in operations and
addressing modes. *)
@@ -1224,7 +1257,7 @@ Definition shift_sp (tf: Mach.function) (sp: val) :=
Remark shift_offset_sp:
forall f tf sp n v,
- transf_function f = Some tf ->
+ transf_function f = OK tf ->
offset_sp sp n = Some v ->
offset_sp (shift_sp tf sp)
(Int.add (Int.repr (fe_size (make_env (function_bounds f)))) n) = Some v.
@@ -1243,11 +1276,11 @@ Proof.
Qed.
Lemma shift_eval_operation:
- forall f tf sp op args v,
- transf_function f = Some tf ->
- eval_operation ge sp op args = Some v ->
+ forall f tf sp op args m v,
+ transf_function f = OK tf ->
+ eval_operation ge sp op args m = Some v ->
eval_operation tge (shift_sp tf sp)
- (transl_op (make_env (function_bounds f)) op) args =
+ (transl_op (make_env (function_bounds f)) op) args m =
Some v.
Proof.
intros until v. destruct op; intros; auto.
@@ -1258,7 +1291,7 @@ Qed.
Lemma shift_eval_addressing:
forall f tf sp addr args v,
- transf_function f = Some tf ->
+ transf_function f = OK tf ->
eval_addressing ge sp addr args = Some v ->
eval_addressing tge (shift_sp tf sp)
(transl_addr (make_env (function_bounds f)) addr) args =
@@ -1282,7 +1315,7 @@ Variable rs: regset.
Variable sg: signature.
Hypothesis AG1: forall r, rs r = ls (R r).
Hypothesis AG2: forall (ofs : Z) (ty : typ),
- 6 <= ofs ->
+ 14 <= ofs ->
ofs + typesize ty <= size_arguments sg ->
get_slot fr ty (Int.signed (Int.repr (4 * ofs)))
(ls (S (Outgoing ofs ty))).
@@ -1319,374 +1352,336 @@ End EXTERNAL_ARGUMENTS.
(** The proof of semantic preservation relies on simulation diagrams
of the following form:
<<
- c, ls, m ------------------- T(c), rs, fr, m
- | |
- | |
- v v
- c', ls', m' ---------------- T(c'), rs', fr', m'
+ st1 --------------- st2
+ | |
+ t| +|t
+ | |
+ v v
+ st1'--------------- st2'
>>
- The left vertical arrow represents a transition in the
- original Linear code. The top horizontal bar captures three preconditions:
-- Agreement between [ls] on the Linear side and [rs], [fr], [rs0]
- on the Mach side.
-- Inclusion between [c] and the code of the function [f] being
- translated.
+ Matching between source and target states is defined by [match_states]
+ below. It implies:
+- Agreement between, on the Linear side, the location sets [ls]
+ and [parent_locset s] of the current function and its caller,
+ and on the Mach side the register set [rs], the frame [fr]
+ and the caller's frame [parent_frame ts].
+- Inclusion between the Linear code [c] and the code of the
+ function [f] being executed.
- Well-typedness of [f].
-
- In conclusion, we want to prove the existence of [rs'], [fr'], [m']
- that satisfies the right arrow (zero, one or several transitions in
- the generated Mach code) and the postcondition (agreement between
- [ls'] and [rs'], [fr'], [rs0]).
-
- As usual, we capture these diagrams as predicates parameterized
- by the transition in the original Linear code. *)
-
-Definition exec_instr_prop
- (f: function) (sp: val)
- (c: code) (ls: locset) (m: mem) (t: trace)
- (c': code) (ls': locset) (m': mem) :=
- forall tf rs fr parent rs0
- (TRANSL: transf_function f = Some tf)
- (WTF: wt_function f)
- (AG: agree f ls rs fr parent rs0)
- (INCL: incl c f.(fn_code)),
- exists rs', exists fr',
- Machabstr.exec_instrs tge tf (shift_sp tf sp) parent
- (transl_code (make_env (function_bounds f)) c) rs fr m
- t (transl_code (make_env (function_bounds f)) c') rs' fr' m'
- /\ agree f ls' rs' fr' parent rs0.
-
-(** The simulation property for function calls has different preconditions
- (a slightly weaker notion of agreement between [ls] and the initial
- register values [rs] and caller's frame [parent]) and different
- postconditions (preservation of callee-save registers). *)
-
-Definition exec_function_prop
- (f: fundef)
- (ls: locset) (m: mem) (t: trace)
- (ls': locset) (m': mem) :=
- forall tf rs parent
- (TRANSL: transf_fundef f = Some tf)
- (WTF: wt_fundef f)
- (AG1: forall r, rs r = ls (R r))
- (AG2: forall ofs ty,
- 6 <= ofs ->
- ofs + typesize ty <= size_arguments (funsig f) ->
- get_slot parent ty (Int.signed (Int.repr (4 * ofs))) (ls (S (Outgoing ofs ty)))),
- exists rs',
- Machabstr.exec_function tge tf parent rs m t rs' m'
- /\ (forall r,
- In (R r) temporaries \/ In (R r) destroyed_at_call ->
- rs' r = ls' (R r))
- /\ (forall r,
- In r int_callee_save_regs \/ In r float_callee_save_regs ->
- rs' r = rs r).
-
-Hypothesis wt_prog: wt_program prog.
-
-Lemma transf_function_correct:
- forall f ls m t ls' m',
- Linear.exec_function ge f ls m t ls' m' ->
- exec_function_prop f ls m t ls' m'.
+*)
+
+Inductive match_stacks: list Linear.stackframe -> list Machabstr.stackframe -> Prop :=
+ | match_stacks_nil:
+ match_stacks nil nil
+ | match_stacks_cons:
+ forall f sp c ls tf fr s ts,
+ match_stacks s ts ->
+ transf_function f = OK tf ->
+ wt_function f ->
+ agree_frame f ls fr (parent_frame ts) (parent_locset s) ->
+ incl c (Linear.fn_code f) ->
+ match_stacks
+ (Linear.Stackframe f sp ls c :: s)
+ (Machabstr.Stackframe tf (shift_sp tf sp) (transl_code (make_env (function_bounds f)) c) fr :: ts).
+
+Inductive match_states: Linear.state -> Machabstr.state -> Prop :=
+ | match_states_intro:
+ forall s f sp c ls m ts tf rs fr
+ (STACKS: match_stacks s ts)
+ (TRANSL: transf_function f = OK tf)
+ (WTF: wt_function f)
+ (AG: agree f ls rs fr (parent_frame ts) (parent_locset s))
+ (INCL: incl c (Linear.fn_code f)),
+ match_states (Linear.State s f sp c ls m)
+ (Machabstr.State ts tf (shift_sp tf sp) (transl_code (make_env (function_bounds f)) c) rs fr m)
+ | match_states_call:
+ forall s f ls m ts tf rs
+ (STACKS: match_stacks s ts)
+ (TRANSL: transf_fundef f = OK tf)
+ (WTF: wt_fundef f)
+ (AG1: forall r, rs r = ls (R r))
+ (AG2: forall ofs ty,
+ 14 <= ofs ->
+ ofs + typesize ty <= size_arguments (Linear.funsig f) ->
+ get_slot (parent_frame ts) ty (Int.signed (Int.repr (4 * ofs))) (ls (S (Outgoing ofs ty))))
+ (AG3: agree_callee_save ls (parent_locset s)),
+ match_states (Linear.Callstate s f ls m)
+ (Machabstr.Callstate ts tf rs m)
+ | match_states_return:
+ forall s ls m ts rs
+ (STACKS: match_stacks s ts)
+ (AG1: forall r, rs r = ls (R r))
+ (AG2: agree_callee_save ls (parent_locset s)),
+ match_states (Linear.Returnstate s ls m)
+ (Machabstr.Returnstate ts rs m).
+
+Theorem transf_step_correct:
+ forall s1 t s2, Linear.step ge s1 t s2 ->
+ forall s1' (MS: match_states s1 s1'),
+ exists s2', plus step tge s1' t s2' /\ match_states s2 s2'.
Proof.
assert (RED: forall f i c,
transl_code (make_env (function_bounds f)) (i :: c) =
transl_instr (make_env (function_bounds f)) i
(transl_code (make_env (function_bounds f)) c)).
intros. reflexivity.
- apply (Linear.exec_function_ind3 ge exec_instr_prop
- exec_instr_prop exec_function_prop);
- intros; red; intros;
- try rewrite RED;
+ induction 1; intros;
+ try inv MS;
+ try rewrite RED;
try (generalize (WTF _ (INCL _ (in_eq _ _))); intro WTI);
+ try (generalize (function_is_within_bounds f WTF _ (INCL _ (in_eq _ _)));
+ intro BOUND; simpl in BOUND);
unfold transl_instr.
-
(* Lgetstack *)
- inversion WTI. exists (rs0#r <- (rs (S sl))); exists fr.
+ inv WTI. destruct BOUND.
+ exists (State ts tf (shift_sp tf sp) (transl_code (make_env (function_bounds f)) b)
+ (rs0#r <- (rs (S sl))) fr m).
split. destruct sl.
(* Lgetstack, local *)
- apply exec_Mgetstack'; auto.
+ apply plus_one. eapply exec_Mgetstack'; eauto.
apply get_slot_index. apply index_local_valid. auto.
eapply agree_size; eauto. reflexivity.
eapply agree_locals; eauto.
(* Lgetstack, incoming *)
- apply Machabstr.exec_one; constructor.
+ apply plus_one; apply exec_Mgetparam.
unfold offset_of_index. eapply agree_incoming; eauto.
(* Lgetstack, outgoing *)
- apply exec_Mgetstack'; auto.
+ apply plus_one; apply exec_Mgetstack'; eauto.
apply get_slot_index. apply index_arg_valid. auto.
eapply agree_size; eauto. reflexivity.
eapply agree_outgoing; eauto.
(* Lgetstack, common *)
+ econstructor; eauto with coqlib.
apply agree_set_reg; auto.
(* Lsetstack *)
- inversion WTI. destruct sl.
+ inv WTI. destruct sl.
+
(* Lsetstack, local *)
- generalize (agree_set_local _ _ _ _ _ _ (rs0 r) _ _ AG H3).
+ generalize (agree_set_local _ _ _ _ _ _ (rs0 r) _ _ AG BOUND).
intros [fr' [SET AG']].
- exists rs0; exists fr'. split.
- apply exec_Msetstack'; auto.
+ econstructor; split.
+ apply plus_one. eapply exec_Msetstack'; eauto.
+ econstructor; eauto with coqlib.
replace (rs (R r)) with (rs0 r). auto.
symmetry. eapply agree_reg; eauto.
(* Lsetstack, incoming *)
contradiction.
(* Lsetstack, outgoing *)
- generalize (agree_set_outgoing _ _ _ _ _ _ (rs0 r) _ _ AG H3).
+ generalize (agree_set_outgoing _ _ _ _ _ _ (rs0 r) _ _ AG BOUND).
intros [fr' [SET AG']].
- exists rs0; exists fr'. split.
- apply exec_Msetstack'; auto.
+ econstructor; split.
+ apply plus_one. eapply exec_Msetstack'; eauto.
+ econstructor; eauto with coqlib.
replace (rs (R r)) with (rs0 r). auto.
symmetry. eapply agree_reg; eauto.
(* Lop *)
- assert (mreg_bounded f res). inversion WTI; auto.
- exists (rs0#res <- v); exists fr. split.
- apply Machabstr.exec_one. constructor.
+ exists (State ts tf (shift_sp tf sp) (transl_code (make_env (function_bounds f)) b) (rs0#res <- v) fr m); split.
+ apply plus_one. apply exec_Mop.
apply shift_eval_operation. auto.
change mreg with RegEq.t.
rewrite (agree_eval_regs _ _ _ _ _ _ args AG). auto.
+ econstructor; eauto with coqlib.
apply agree_set_reg; auto.
(* Lload *)
- inversion WTI. exists (rs0#dst <- v); exists fr. split.
- apply Machabstr.exec_one; econstructor.
+ exists (State ts tf (shift_sp tf sp) (transl_code (make_env (function_bounds f)) b) (rs0#dst <- v) fr m); split.
+ apply plus_one; eapply exec_Mload; eauto.
apply shift_eval_addressing; auto.
change mreg with RegEq.t.
rewrite (agree_eval_regs _ _ _ _ _ _ args AG). eauto.
- auto.
+ econstructor; eauto with coqlib.
apply agree_set_reg; auto.
(* Lstore *)
- exists rs0; exists fr. split.
- apply Machabstr.exec_one; econstructor.
- apply shift_eval_addressing; auto.
+ econstructor; split.
+ apply plus_one; eapply exec_Mstore; eauto.
+ apply shift_eval_addressing; eauto.
change mreg with RegEq.t.
rewrite (agree_eval_regs _ _ _ _ _ _ args AG). eauto.
- rewrite (agree_eval_reg _ _ _ _ _ _ src AG). auto.
- auto.
-
- (* Lcall *)
- inversion WTI.
- assert (WTF': wt_fundef f').
- destruct ros; simpl in H.
- apply (Genv.find_funct_prop wt_fundef wt_prog H).
- destruct (Genv.find_symbol ge i); try discriminate.
- apply (Genv.find_funct_ptr_prop wt_fundef wt_prog H).
- assert (TR: exists tf', Mach.find_function tge ros rs0 = Some tf'
- /\ transf_fundef f' = Some tf').
- destruct ros; simpl in H; simpl.
- eapply functions_translated.
- rewrite (agree_eval_reg _ _ _ _ _ _ m0 AG). auto.
- rewrite symbols_preserved.
- destruct (Genv.find_symbol ge i); try discriminate.
- apply function_ptr_translated; auto.
- elim TR; intros tf' [FIND' TRANSL']; clear TR.
- assert (AG1: forall r, rs0 r = rs (R r)).
- intro. symmetry. eapply agree_reg; eauto.
- assert (AG2: forall ofs ty,
- 6 <= ofs ->
- ofs + typesize ty <= size_arguments (funsig f') ->
- get_slot fr ty (Int.signed (Int.repr (4 * ofs))) (rs (S (Outgoing ofs ty)))).
- intros.
- assert (slot_bounded f (Outgoing ofs ty)).
- red. rewrite <- H0 in H8. omega.
- change (4 * ofs) with (offset_of_index (make_env (function_bounds f)) (FI_arg ofs ty)).
- rewrite (offset_of_index_no_overflow f tf); auto.
- apply get_slot_index. apply index_arg_valid. auto.
- eapply agree_size; eauto. reflexivity.
- eapply agree_outgoing; eauto.
- generalize (H2 tf' rs0 fr TRANSL' WTF' AG1 AG2).
- intros [rs2 [EXF [REGS1 REGS2]]].
- exists rs2; exists fr. split.
- apply Machabstr.exec_one; apply Machabstr.exec_Mcall with tf'; auto.
- apply agree_return_regs with rs0; auto.
-
+ rewrite (agree_eval_reg _ _ _ _ _ _ src AG). eauto.
+ econstructor; eauto with coqlib.
+
+ (* Lcall *)
+ assert (WTF': wt_fundef f'). eapply find_function_well_typed; eauto.
+ exploit find_function_translated; eauto.
+ intros [tf' [FIND' TRANSL']].
+ econstructor; split.
+ apply plus_one; eapply exec_Mcall; eauto.
+ econstructor; eauto.
+ econstructor; eauto with coqlib.
+ exists rs0; auto.
+ intro. symmetry. eapply agree_reg; eauto.
+ intros.
+ assert (slot_within_bounds f (function_bounds f) (Outgoing ofs ty)).
+ red. simpl. omega.
+ change (4 * ofs) with (offset_of_index (make_env (function_bounds f)) (FI_arg ofs ty)).
+ rewrite (offset_of_index_no_overflow f tf); auto.
+ apply get_slot_index. apply index_arg_valid. auto.
+ eapply agree_size; eauto. reflexivity.
+ eapply agree_outgoing; eauto.
+ simpl. red; auto.
+
+ (* Ltailcall *)
+ assert (WTF': wt_fundef f'). eapply find_function_well_typed; eauto.
+ generalize (find_function_translated _ _ _ _ _ _ _ _ AG H).
+ intros [tf' [FIND' TRANSL']].
+ generalize (restore_callee_save_correct ts _ _ TRANSL
+ (shift_sp tf (Vptr stk Int.zero))
+ (Mtailcall (Linear.funsig f') ros :: transl_code (make_env (function_bounds f)) b)
+ _ m _ _ _ AG).
+ intros [rs2 [A [B C]]].
+ assert (FIND'': find_function tge ros rs2 = Some tf').
+ rewrite <- FIND'. destruct ros; simpl; auto.
+ inv WTI. rewrite C. auto.
+ simpl. intuition congruence. simpl. intuition congruence.
+ econstructor; split.
+ eapply plus_right. eexact A.
+ simpl shift_sp. eapply exec_Mtailcall; eauto. traceEq.
+ econstructor; eauto.
+ intros; symmetry; eapply agree_return_regs; eauto.
+ intros. inv WTI. rewrite tailcall_possible_size in H4.
+ rewrite H4 in H1. elimtype False. generalize (typesize_pos ty). omega.
+ apply agree_callee_save_return_regs.
+
(* Lalloc *)
- exists (rs0#loc_alloc_result <- (Vptr blk Int.zero)); exists fr. split.
- apply Machabstr.exec_one; eapply Machabstr.exec_Malloc; eauto.
+ exists (State ts tf (shift_sp tf sp) (transl_code (make_env (function_bounds f)) b)
+ (rs0#loc_alloc_result <- (Vptr blk Int.zero)) fr m'); split.
+ apply plus_one; eapply exec_Malloc; eauto.
rewrite (agree_eval_reg _ _ _ _ _ _ loc_alloc_argument AG). auto.
+ econstructor; eauto with coqlib.
apply agree_set_reg; auto.
red. simpl. generalize (max_over_regs_of_funct_pos f int_callee_save). omega.
(* Llabel *)
- exists rs0; exists fr. split.
- apply Machabstr.exec_one; apply Machabstr.exec_Mlabel.
- auto.
+ econstructor; split.
+ apply plus_one; apply exec_Mlabel.
+ econstructor; eauto with coqlib.
(* Lgoto *)
- exists rs0; exists fr. split.
- apply Machabstr.exec_one; apply Machabstr.exec_Mgoto.
- apply transl_find_label; auto.
- auto.
+ econstructor; split.
+ apply plus_one; apply exec_Mgoto.
+ apply transl_find_label; eauto.
+ econstructor; eauto.
+ eapply find_label_incl; eauto.
(* Lcond, true *)
- exists rs0; exists fr. split.
- apply Machabstr.exec_one; apply Machabstr.exec_Mcond_true.
- rewrite <- (agree_eval_regs _ _ _ _ _ _ args AG) in H; auto.
- apply transl_find_label; auto.
- auto.
+ econstructor; split.
+ apply plus_one; apply exec_Mcond_true.
+ rewrite <- (agree_eval_regs _ _ _ _ _ _ args AG) in H; eauto.
+ apply transl_find_label; eauto.
+ econstructor; eauto.
+ eapply find_label_incl; eauto.
(* Lcond, false *)
- exists rs0; exists fr. split.
- apply Machabstr.exec_one; apply Machabstr.exec_Mcond_false.
+ econstructor; split.
+ apply plus_one; apply exec_Mcond_false.
rewrite <- (agree_eval_regs _ _ _ _ _ _ args AG) in H; auto.
- auto.
-
- (* refl *)
- exists rs0; exists fr. split. apply Machabstr.exec_refl. auto.
-
- (* one *)
- apply H0; auto.
-
- (* trans *)
- generalize (H0 tf rs fr parent rs0 TRANSL WTF AG INCL).
- intros [rs' [fr' [A B]]].
- assert (INCL': incl b2 (fn_code f)). eapply exec_instrs_incl; eauto.
- generalize (H2 tf rs' fr' parent rs0 TRANSL WTF B INCL').
- intros [rs'' [fr'' [C D]]].
- exists rs''; exists fr''. split.
- eapply Machabstr.exec_trans. eexact A. eexact C. auto.
- auto.
-
- (* function *)
+ econstructor; eauto with coqlib.
+
+ (* Lreturn *)
+ exploit restore_callee_save_correct; eauto.
+ intros [ls' [A [B C]]].
+ econstructor; split.
+ eapply plus_right. eauto.
+ simpl shift_sp. econstructor; eauto. traceEq.
+ econstructor; eauto.
+ intros. symmetry. eapply agree_return_regs; eauto.
+ apply agree_callee_save_return_regs.
+
+ (* internal function *)
generalize TRANSL; clear TRANSL.
unfold transf_fundef, transf_partial_fundef.
- caseEq (transf_function f); try congruence.
+ caseEq (transf_function f); simpl; try congruence.
intros tfn TRANSL EQ. inversion EQ; clear EQ; subst tf.
inversion WTF as [|f' WTFN]. subst f'.
- assert (X: forall link ra,
- exists rs' : regset,
- Machabstr.exec_function_body tge tfn parent link ra rs0 m t rs' (free m2 stk) /\
- (forall r : mreg,
- In (R r) temporaries \/ In (R r) destroyed_at_call -> rs' r = rs2 (R r)) /\
- (forall r : mreg,
- In r int_callee_save_regs \/ In r float_callee_save_regs -> rs' r = rs0 r)).
- intros.
set (sp := Vptr stk Int.zero) in *.
set (tsp := shift_sp tfn sp).
set (fe := make_env (function_bounds f)).
- assert (low (init_frame tfn) = -fe.(fe_size)).
- simpl low. rewrite (unfold_transf_function _ _ TRANSL).
+ assert (fr_low (init_frame tfn) = - fe.(fe_size)).
+ simpl fr_low. rewrite (unfold_transf_function _ _ TRANSL).
reflexivity.
- assert (exists fr1, set_slot (init_frame tfn) Tint 0 link fr1).
- apply set_slot_ok. reflexivity. omega. rewrite H2. generalize (size_pos f).
- unfold fe. simpl typesize. omega.
- elim H3; intros fr1 SET1; clear H3.
- assert (high fr1 = 0).
- inversion SET1. reflexivity.
- assert (low fr1 = -fe.(fe_size)).
- inversion SET1. rewrite <- H2. reflexivity.
- assert (exists fr2, set_slot fr1 Tint 12 ra fr2).
- apply set_slot_ok. auto. omega. rewrite H4. generalize (size_pos f).
- unfold fe. simpl typesize. omega.
- elim H5; intros fr2 SET2; clear H5.
- assert (high fr2 = 0).
- inversion SET2. simpl. auto.
- assert (low fr2 = -fe.(fe_size)).
- inversion SET2. rewrite <- H4. reflexivity.
- assert (UNDEF: forall idx, index_valid f idx -> index_val f idx fr2 = Vundef).
- intros.
- assert (get_slot fr2 (type_of_index idx) (offset_of_index fe idx) Vundef).
- generalize (offset_of_index_valid _ _ H7). fold fe. intros [XX YY].
- eapply slot_gso; eauto.
- eapply slot_gso; eauto.
- apply slot_gi. omega. omega.
- simpl typesize. omega. simpl typesize. omega.
- inversion H8. symmetry. exact H11.
- generalize (save_callee_save_correct f tfn TRANSL
- tsp parent
- (transl_code (make_env (function_bounds f)) f.(fn_code))
- rs0 fr2 m1 rs AG1 AG2 H5 H6 UNDEF).
+ assert (UNDEF: forall idx, index_valid f idx -> index_val f idx (init_frame tfn) = Vundef).
+ intros.
+ assert (get_slot (init_frame tfn) (type_of_index idx) (offset_of_index fe idx) Vundef).
+ generalize (offset_of_index_valid _ _ H1). fold fe. intros [XX YY].
+ apply slot_gi; auto. omega.
+ inv H2; auto.
+ exploit save_callee_save_correct; eauto.
intros [fr [EXP AG]].
- generalize (H1 tfn rs0 fr parent rs0 TRANSL WTFN AG (incl_refl _)).
- intros [rs' [fr' [EXB AG']]].
- generalize (restore_callee_save_correct f tfn TRANSL tsp parent
- (Mreturn :: transl_code (make_env (function_bounds f)) b)
- fr' m2 rs0 rs2 rs' AG').
- intros [rs'' [EXX [REGS1 REGS2]]].
- exists rs''. split. eapply Machabstr.exec_funct_body.
- rewrite (unfold_transf_function f tfn TRANSL); eexact H.
- eexact SET1. eexact SET2.
- replace (Mach.fn_code tfn) with
- (transl_body f (make_env (function_bounds f))).
- replace (Vptr stk (Int.repr (- fn_framesize tfn))) with tsp.
- eapply Machabstr.exec_trans. eexact EXP.
- eapply Machabstr.exec_trans. eexact EXB. eexact EXX.
- reflexivity. traceEq.
- unfold tsp, shift_sp, sp. unfold Val.add.
- rewrite Int.add_commut. rewrite Int.add_zero. auto.
- rewrite (unfold_transf_function f tfn TRANSL). simpl. auto.
- split. intros. rewrite REGS2. symmetry; eapply agree_reg; eauto.
- apply int_callee_save_not_destroyed; auto.
- apply float_callee_save_not_destroyed; auto.
- auto.
- generalize (X Vzero Vzero). intros [rs' [EX [REGS1 REGS2]]].
- exists rs'. split.
- constructor. intros.
- generalize (X link ra). intros [rs'' [EX' [REGS1' REGS2']]].
- assert (rs' = rs'').
- apply (@Regmap.exten val). intro r.
- elim (register_classification r); intro.
- rewrite REGS1'. apply REGS1. auto. auto.
- rewrite REGS2'. apply REGS2. auto. auto.
- rewrite H4. auto.
- split; auto.
+ econstructor; split.
+ eapply plus_left.
+ eapply exec_function_internal; eauto.
+ rewrite (unfold_transf_function f tfn TRANSL); simpl; eexact H.
+ replace (Mach.fn_code tfn) with
+ (transl_body f (make_env (function_bounds f))).
+ replace (Vptr stk (Int.repr (- fn_framesize tfn))) with tsp.
+ unfold transl_body. eexact EXP.
+ unfold tsp, shift_sp, sp. unfold Val.add.
+ rewrite Int.add_commut. rewrite Int.add_zero. auto.
+ rewrite (unfold_transf_function f tfn TRANSL). simpl. auto.
+ traceEq.
+ unfold tsp. econstructor; eauto with coqlib.
+ eapply agree_callee_save_agree; eauto.
(* external function *)
simpl in TRANSL. inversion TRANSL; subst tf.
- inversion WTF. subst ef0. set (sg := ef_sig ef) in *.
- exists (rs#(loc_result sg) <- res).
- split. econstructor. eauto.
- fold sg. rewrite H0. apply transl_external_arguments; assumption.
- reflexivity.
- split; intros. rewrite H1.
- unfold Regmap.set. case (RegEq.eq r (loc_result sg)); intro.
+ inversion WTF. subst ef0.
+ exploit transl_external_arguments; eauto. intro EXTARGS.
+ econstructor; split.
+ apply plus_one. eapply exec_function_external; eauto.
+ econstructor; eauto.
+ intros. unfold Regmap.set. case (RegEq.eq r (loc_result (ef_sig ef))); intro.
rewrite e. rewrite Locmap.gss; auto. rewrite Locmap.gso; auto.
red; auto.
- apply Regmap.gso. red; intro; subst r.
- elim (Conventions.loc_result_not_callee_save _ H2).
+ apply agree_callee_save_set_result; auto.
+
+ (* return *)
+ inv STACKS.
+ econstructor; split.
+ apply plus_one. apply exec_return.
+ econstructor; eauto. simpl in AG2.
+ eapply agree_frame_agree; eauto.
Qed.
-End PRESERVATION.
+Lemma transf_initial_states:
+ forall st1, Linear.initial_state prog st1 ->
+ exists st2, Machabstr.initial_state tprog st2 /\ match_states st1 st2.
+Proof.
+ intros. inversion H.
+ exploit function_ptr_translated; eauto. intros [tf [FIND TR]].
+ econstructor; split.
+ econstructor.
+ rewrite (transform_partial_program_main _ _ TRANSF).
+ rewrite symbols_preserved. eauto.
+ eauto.
+ rewrite (Genv.init_mem_transf_partial _ _ TRANSF).
+ econstructor; eauto. constructor.
+ eapply Genv.find_funct_ptr_prop; eauto.
+ intros.
+ replace (size_arguments (Linear.funsig f)) with 14 in H5.
+ elimtype False. generalize (typesize_pos ty). omega.
+ rewrite H2; auto.
+ simpl; red; auto.
+Qed.
-Theorem transl_program_correct:
- forall (p: Linear.program) (tp: Mach.program) (t: trace) (r: val),
- wt_program p ->
- transf_program p = Some tp ->
- Linear.exec_program p t r ->
- Machabstr.exec_program tp t r.
-Proof.
- intros p tp t r WTP TRANSF
- [fptr [f [ls' [m [FINDSYMB [FINDFUNC [SIG [EXEC RES]]]]]]]].
- assert (WTF: wt_fundef f).
- apply (Genv.find_funct_ptr_prop wt_fundef WTP FINDFUNC).
- set (ls := Locmap.init Vundef) in *.
- set (rs := Regmap.init Vundef).
- set (fr := empty_frame).
- assert (AG1: forall r, rs r = ls (R r)).
- intros; reflexivity.
- assert (AG2: forall ofs ty,
- 6 <= ofs ->
- ofs + typesize ty <= size_arguments (funsig f) ->
- get_slot fr ty (Int.signed (Int.repr (4 * ofs))) (ls (S (Outgoing ofs ty)))).
- rewrite SIG. unfold size_arguments, sig_args, size_arguments_rec.
- intros. generalize (typesize_pos ty).
- intro. omegaContradiction.
- generalize (function_ptr_translated p tp TRANSF f _ FINDFUNC).
- intros [tf [TFIND TRANSL]].
- generalize (transf_function_correct p tp TRANSF WTP _ _ _ _ _ _ EXEC
- tf rs fr TRANSL WTF AG1 AG2).
- intros [rs' [A [B C]]].
- red. exists fptr; exists tf; exists rs'; exists m.
- split. rewrite (symbols_preserved p tp TRANSF).
- rewrite (transform_partial_program_main transf_fundef p TRANSF).
- assumption.
- split. assumption.
- split. replace (Genv.init_mem tp) with (Genv.init_mem p).
- exact A. symmetry. apply Genv.init_mem_transf_partial with transf_fundef.
- exact TRANSF.
- rewrite <- RES. replace R3 with (loc_result (funsig f)).
- apply B. right. apply loc_result_acceptable.
- rewrite SIG; reflexivity.
+Lemma transf_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 -> Linear.final_state st1 r -> Machabstr.final_state st2 r.
+Proof.
+ intros. inv H0. inv H. inv STACKS. econstructor. rewrite AG1; auto.
+Qed.
+
+Theorem transf_program_correct:
+ forall (beh: program_behavior),
+ Linear.exec_program prog beh -> Machabstr.exec_program tprog beh.
+Proof.
+ unfold Linear.exec_program, Machabstr.exec_program; intros.
+ eapply simulation_plus_preservation; eauto.
+ eexact transf_initial_states.
+ eexact transf_final_states.
+ eexact transf_step_correct.
Qed.
+
+End PRESERVATION.
diff --git a/backend/Stackingtyping.v b/backend/Stackingtyping.v
index beb28e2942a2d70e6408174b78e6a05787474a9e..fa8a3e2eaf786da43e666448446010fc96716858 100644
--- a/backend/Stackingtyping.v
+++ b/backend/Stackingtyping.v
@@ -2,6 +2,7 @@
Require Import Coqlib.
Require Import Maps.
+Require Import Errors.
Require Import Integers.
Require Import AST.
Require Import Op.
@@ -11,11 +12,12 @@ Require Import Linear.
Require Import Lineartyping.
Require Import Mach.
Require Import Machtyping.
+Require Import Bounds.
Require Import Stacking.
Require Import Stackingproof.
(** We show that the Mach code generated by the [Stacking] pass
- is well-typed if the original Linear code is. *)
+ is well-typed if the original LTLin code is. *)
Definition wt_instrs (k: Mach.code) : Prop :=
forall i, In i k -> wt_instr i.
@@ -33,17 +35,7 @@ Section TRANSL_FUNCTION.
Variable f: Linear.function.
Let fe := make_env (function_bounds f).
Variable tf: Mach.function.
-Hypothesis TRANSF_F: transf_function f = Some tf.
-
-Lemma wt_Msetstack':
- forall idx ty r,
- mreg_type r = ty -> index_valid f idx ->
- wt_instr (Msetstack r (Int.repr (offset_of_index fe idx)) ty).
-Proof.
- intros. constructor. auto.
- unfold fe. rewrite (offset_of_index_no_overflow f tf TRANSF_F); auto.
- generalize (offset_of_index_valid f idx H0). tauto.
-Qed.
+Hypothesis TRANSF_F: transf_function f = OK tf.
Lemma wt_fold_right:
forall (A: Set) (f: A -> code -> code) (k: code) (l: list A),
@@ -58,51 +50,57 @@ Proof.
auto.
Qed.
-Lemma wt_save_int_callee_save:
- forall cs k,
- In cs int_callee_save_regs -> wt_instrs k ->
- wt_instrs (save_int_callee_save fe cs k).
+Lemma wt_save_callee_save_int:
+ forall k,
+ wt_instrs k ->
+ wt_instrs (save_callee_save_int fe k).
Proof.
- intros. unfold save_int_callee_save.
- case (zlt (index_int_callee_save cs) (fe_num_int_callee_save fe)); intro.
+ intros. unfold save_callee_save_int, save_callee_save_regs.
+ apply wt_fold_right; auto.
+ intros. unfold save_callee_save_reg.
+ case (zlt (index_int_callee_save x) (fe_num_int_callee_save fe)); intro.
apply wt_instrs_cons; auto.
- apply wt_Msetstack'. apply int_callee_save_type; auto.
- apply index_saved_int_valid. auto. exact z.
+ apply wt_Msetstack. apply int_callee_save_type; auto.
auto.
Qed.
-Lemma wt_save_float_callee_save:
- forall cs k,
- In cs float_callee_save_regs -> wt_instrs k ->
- wt_instrs (save_float_callee_save fe cs k).
+Lemma wt_save_callee_save_float:
+ forall k,
+ wt_instrs k ->
+ wt_instrs (save_callee_save_float fe k).
Proof.
- intros. unfold save_float_callee_save.
- case (zlt (index_float_callee_save cs) (fe_num_float_callee_save fe)); intro.
+ intros. unfold save_callee_save_float, save_callee_save_regs.
+ apply wt_fold_right; auto.
+ intros. unfold save_callee_save_reg.
+ case (zlt (index_float_callee_save x) (fe_num_float_callee_save fe)); intro.
apply wt_instrs_cons; auto.
- apply wt_Msetstack'. apply float_callee_save_type; auto.
- apply index_saved_float_valid. auto. exact z.
+ apply wt_Msetstack. apply float_callee_save_type; auto.
auto.
Qed.
-Lemma wt_restore_int_callee_save:
- forall cs k,
- In cs int_callee_save_regs -> wt_instrs k ->
- wt_instrs (restore_int_callee_save fe cs k).
+Lemma wt_restore_callee_save_int:
+ forall k,
+ wt_instrs k ->
+ wt_instrs (restore_callee_save_int fe k).
Proof.
- intros. unfold restore_int_callee_save.
- case (zlt (index_int_callee_save cs) (fe_num_int_callee_save fe)); intro.
+ intros. unfold restore_callee_save_int, restore_callee_save_regs.
+ apply wt_fold_right; auto.
+ intros. unfold restore_callee_save_reg.
+ case (zlt (index_int_callee_save x) (fe_num_int_callee_save fe)); intro.
apply wt_instrs_cons; auto.
constructor. apply int_callee_save_type; auto.
auto.
Qed.
-Lemma wt_restore_float_callee_save:
- forall cs k,
- In cs float_callee_save_regs -> wt_instrs k ->
- wt_instrs (restore_float_callee_save fe cs k).
+Lemma wt_restore_callee_save_float:
+ forall k,
+ wt_instrs k ->
+ wt_instrs (restore_callee_save_float fe k).
Proof.
- intros. unfold restore_float_callee_save.
- case (zlt (index_float_callee_save cs) (fe_num_float_callee_save fe)); intro.
+ intros. unfold restore_callee_save_float, restore_callee_save_regs.
+ apply wt_fold_right; auto.
+ intros. unfold restore_callee_save_reg.
+ case (zlt (index_float_callee_save x) (fe_num_float_callee_save fe)); intro.
apply wt_instrs_cons; auto.
constructor. apply float_callee_save_type; auto.
auto.
@@ -113,9 +111,7 @@ Lemma wt_save_callee_save:
wt_instrs k -> wt_instrs (save_callee_save fe k).
Proof.
intros. unfold save_callee_save.
- apply wt_fold_right. exact wt_save_int_callee_save.
- apply wt_fold_right. exact wt_save_float_callee_save.
- auto.
+ apply wt_save_callee_save_int. apply wt_save_callee_save_float. auto.
Qed.
Lemma wt_restore_callee_save:
@@ -123,37 +119,34 @@ Lemma wt_restore_callee_save:
wt_instrs k -> wt_instrs (restore_callee_save fe k).
Proof.
intros. unfold restore_callee_save.
- apply wt_fold_right. exact wt_restore_int_callee_save.
- apply wt_fold_right. exact wt_restore_float_callee_save.
- auto.
+ apply wt_restore_callee_save_int. apply wt_restore_callee_save_float. auto.
Qed.
Lemma wt_transl_instr:
forall instr k,
+ In instr f.(Linear.fn_code) ->
Lineartyping.wt_instr f instr ->
wt_instrs k ->
wt_instrs (transl_instr fe instr k).
Proof.
- intros. destruct instr; unfold transl_instr; inversion H.
+ intros.
+ generalize (instr_is_within_bounds f instr H H0); intro BND.
+ destruct instr; unfold transl_instr; inv H0; simpl in BND.
(* getstack *)
- destruct s; simpl in H3; apply wt_instrs_cons; auto;
+ destruct BND.
+ destruct s; simpl in *; apply wt_instrs_cons; auto;
constructor; auto.
(* setstack *)
- destruct s; simpl in H3; simpl in H4.
- apply wt_instrs_cons; auto. apply wt_Msetstack'. auto.
- apply index_local_valid. auto.
+ destruct s.
+ apply wt_instrs_cons; auto. apply wt_Msetstack. auto.
auto.
- apply wt_instrs_cons; auto. apply wt_Msetstack'. auto.
- apply index_arg_valid. auto.
+ apply wt_instrs_cons; auto. apply wt_Msetstack. auto.
(* op, move *)
simpl. apply wt_instrs_cons. constructor; auto. auto.
- (* op, undef *)
- simpl. apply wt_instrs_cons. constructor. auto.
(* op, others *)
apply wt_instrs_cons; auto.
constructor.
destruct o; simpl; congruence.
- destruct o; simpl; congruence.
rewrite H6. destruct o; reflexivity || congruence.
(* load *)
apply wt_instrs_cons; auto.
@@ -162,10 +155,14 @@ Proof.
(* store *)
apply wt_instrs_cons; auto.
constructor; auto.
- rewrite H3. destruct a; reflexivity.
+ rewrite H4. destruct a; reflexivity.
(* call *)
apply wt_instrs_cons; auto.
constructor; auto.
+ (* tailcall *)
+ apply wt_restore_callee_save. apply wt_instrs_cons; auto.
+ constructor; auto.
+ destruct s0; auto. rewrite H5; auto.
(* alloc *)
apply wt_instrs_cons; auto. constructor.
(* label *)
@@ -185,7 +182,7 @@ End TRANSL_FUNCTION.
Lemma wt_transf_function:
forall f tf,
- transf_function f = Some tf ->
+ transf_function f = OK tf ->
Lineartyping.wt_function f ->
wt_function tf.
Proof.
@@ -201,7 +198,7 @@ Proof.
constructor.
change (wt_instrs (fn_code tf)).
rewrite H1; simpl; unfold transl_body.
- apply wt_save_callee_save with tf; auto.
+ apply wt_save_callee_save; auto.
unfold transl_code. apply wt_fold_right.
intros. eapply wt_transl_instr; eauto.
red; intros. elim H3.
@@ -213,20 +210,20 @@ Qed.
Lemma wt_transf_fundef:
forall f tf,
Lineartyping.wt_fundef f ->
- transf_fundef f = Some tf ->
+ transf_fundef f = OK tf ->
wt_fundef tf.
Proof.
intros f tf WT. inversion WT; subst.
simpl; intros; inversion H. constructor.
unfold transf_fundef, transf_partial_fundef.
- caseEq (transf_function f0); try congruence.
+ caseEq (transf_function f0); simpl; try congruence.
intros tfn TRANSF EQ. inversion EQ; subst tf.
constructor; eapply wt_transf_function; eauto.
Qed.
Lemma program_typing_preserved:
forall (p: Linear.program) (tp: Mach.program),
- transf_program p = Some tp ->
+ transf_program p = OK tp ->
Lineartyping.wt_program p ->
Machtyping.wt_program tp.
Proof.
diff --git a/backend/Tunneling.v b/backend/Tunneling.v
index 4fbdc9fd1427298c0d63f7af00bd209096dc8f26..15f4676d7df3edb98c65fbd85204a9fee5a5cf41 100644
--- a/backend/Tunneling.v
+++ b/backend/Tunneling.v
@@ -30,8 +30,8 @@ Require Import LTL.
dead code (as the "goto L3" in the example above).
*)
-Definition is_goto_block (b: option block) : option node :=
- match b with Some (Bgoto s) => Some s | _ => None end.
+Definition is_goto_instr (b: option instruction) : option node :=
+ match b with Some (Lnop s) => Some s | _ => None end.
(** [branch_target f pc] returns the node of the CFG that is at
the end of the branch sequence starting at [pc]. If the instruction
@@ -70,7 +70,7 @@ Fixpoint branch_target_rec (f: LTL.function) (pc: node) (count: nat)
match count with
| Datatypes.O => None
| Datatypes.S count' =>
- match is_goto_block f.(fn_code)!pc with
+ match is_goto_instr f.(fn_code)!pc with
| Some s => branch_target_rec f s count'
| None => Some pc
end
@@ -86,34 +86,32 @@ Definition branch_target (f: LTL.function) (pc: node) :=
replacing the destinations of the [Bgoto] and [Bcond] instructions
with their final target, as computed by [branch_target]. *)
-Fixpoint tunnel_block (f: LTL.function) (b: block) {struct b} : block :=
+Definition tunnel_instr (f: LTL.function) (b: instruction) : instruction :=
match b with
- | Bgetstack s r b =>
- Bgetstack s r (tunnel_block f b)
- | Bsetstack r s b =>
- Bsetstack r s (tunnel_block f b)
- | Bop op args res b =>
- Bop op args res (tunnel_block f b)
- | Bload chunk addr args dst b =>
- Bload chunk addr args dst (tunnel_block f b)
- | Bstore chunk addr args src b =>
- Bstore chunk addr args src (tunnel_block f b)
- | Bcall sig ros b =>
- Bcall sig ros (tunnel_block f b)
- | Balloc b =>
- Balloc (tunnel_block f b)
- | Bgoto s =>
- Bgoto (branch_target f s)
- | Bcond cond args s1 s2 =>
- Bcond cond args (branch_target f s1) (branch_target f s2)
- | Breturn =>
- Breturn
+ | Lnop s =>
+ Lnop (branch_target f s)
+ | Lop op args res s =>
+ Lop op args res (branch_target f s)
+ | Lload chunk addr args dst s =>
+ Lload chunk addr args dst (branch_target f s)
+ | Lstore chunk addr args src s =>
+ Lstore chunk addr args src (branch_target f s)
+ | Lcall sig ros args res s =>
+ Lcall sig ros args res (branch_target f s)
+ | Ltailcall sig ros args =>
+ Ltailcall sig ros args
+ | Lalloc arg res s =>
+ Lalloc arg res (branch_target f s)
+ | Lcond cond args s1 s2 =>
+ Lcond cond args (branch_target f s1) (branch_target f s2)
+ | Lreturn or =>
+ Lreturn or
end.
Lemma wf_tunneled_code:
forall (f: LTL.function),
- let tc := PTree.map (fun pc b => tunnel_block f b) (fn_code f) in
- forall (pc: node), Plt pc (Psucc (fn_entrypoint f)) \/ tc!pc = None.
+ let tc := PTree.map (fun pc b => tunnel_instr f b) (fn_code f) in
+ forall (pc: node), Plt pc (fn_nextpc f) \/ tc!pc = None.
Proof.
intros. elim (fn_code_wf f pc); intro.
left; auto. right; unfold tc.
@@ -123,9 +121,11 @@ Qed.
Definition tunnel_function (f: LTL.function) : LTL.function :=
mkfunction
(fn_sig f)
+ (fn_params f)
(fn_stacksize f)
- (PTree.map (fun pc b => tunnel_block f b) (fn_code f))
- (fn_entrypoint f)
+ (PTree.map (fun pc b => tunnel_instr f b) (fn_code f))
+ (branch_target f (fn_entrypoint f))
+ (fn_nextpc f)
(wf_tunneled_code f).
Definition tunnel_fundef (f: LTL.fundef) : LTL.fundef :=
diff --git a/backend/Tunnelingproof.v b/backend/Tunnelingproof.v
index eae53cac7936b3da09f3c1006778367185aba605..3777eaa9d42ba4dba761f0adec180ecf216b056b 100644
--- a/backend/Tunnelingproof.v
+++ b/backend/Tunnelingproof.v
@@ -7,6 +7,7 @@ Require Import Values.
Require Import Mem.
Require Import Events.
Require Import Globalenvs.
+Require Import Smallstep.
Require Import Op.
Require Import Locations.
Require Import LTL.
@@ -14,51 +15,85 @@ Require Import Tunneling.
(** * Properties of branch target computation *)
-Lemma is_goto_block_correct:
+Lemma is_goto_instr_correct:
forall b s,
- is_goto_block b = Some s -> b = Some (Bgoto s).
+ is_goto_instr b = Some s -> b = Some (Lnop s).
Proof.
- unfold is_goto_block; intros.
- destruct b. destruct b; discriminate || congruence.
- discriminate.
+ unfold is_goto_instr; intros.
+ destruct b; try discriminate.
+ destruct i; discriminate || congruence.
Qed.
Lemma branch_target_rec_1:
forall f pc n,
branch_target_rec f pc n = Some pc
\/ branch_target_rec f pc n = None
- \/ exists pc', f.(fn_code)!pc = Some(Bgoto pc').
+ \/ exists pc', f.(fn_code)!pc = Some(Lnop pc').
Proof.
intros. destruct n; simpl.
right; left; auto.
- caseEq (is_goto_block f.(fn_code)!pc); intros.
- right; right. exists n0. apply is_goto_block_correct; auto.
+ caseEq (is_goto_instr f.(fn_code)!pc); intros.
+ right; right. exists n0. apply is_goto_instr_correct; auto.
left; auto.
Qed.
Lemma branch_target_rec_2:
forall f n pc1 pc2 pc3,
- f.(fn_code)!pc1 = Some (Bgoto pc2) ->
+ f.(fn_code)!pc1 = Some (Lnop pc2) ->
branch_target_rec f pc1 n = Some pc3 ->
branch_target_rec f pc2 n = Some pc3.
Proof.
induction n.
simpl. intros; discriminate.
intros pc1 pc2 pc3 ATpc1 H. simpl in H.
- unfold is_goto_block in H; rewrite ATpc1 in H.
- simpl. caseEq (is_goto_block f.(fn_code)!pc2); intros.
- apply IHn with pc2. apply is_goto_block_correct; auto. auto.
+ unfold is_goto_instr in H; rewrite ATpc1 in H.
+ simpl. caseEq (is_goto_instr f.(fn_code)!pc2); intros.
+ apply IHn with pc2. apply is_goto_instr_correct; auto. auto.
destruct n; simpl in H. discriminate. rewrite H0 in H. auto.
Qed.
+(** Counting the number of consecutive gotos. *)
+
+Fixpoint count_goto_rec (f: LTL.function) (pc: node) (count: nat)
+ {struct count} : nat :=
+ match count with
+ | Datatypes.O => Datatypes.O
+ | Datatypes.S count' =>
+ match is_goto_instr f.(fn_code)!pc with
+ | Some s => Datatypes.S (count_goto_rec f s count')
+ | None => Datatypes.O
+ end
+ end.
+
+Definition count_goto (f: LTL.function) (pc: node) : nat :=
+ count_goto_rec f pc 10%nat.
+
+Lemma count_goto_rec_prop:
+ forall f n pc1 pc2 pc3,
+ f.(fn_code)!pc1 = Some (Lnop pc2) ->
+ branch_target_rec f pc1 n = Some pc3 ->
+ (count_goto_rec f pc2 n < count_goto_rec f pc1 n)%nat.
+Proof.
+ induction n.
+ simpl; intros. discriminate.
+ intros pc1 pc2 pc3 ATpc1 H. simpl in H.
+ unfold is_goto_instr in H; rewrite ATpc1 in H.
+ simpl. unfold is_goto_instr at 2. rewrite ATpc1.
+ caseEq (is_goto_instr f.(fn_code)!pc2); intros.
+ exploit (IHn pc2); eauto. apply is_goto_instr_correct; eauto.
+ omega.
+ omega.
+Qed.
+
(** The following lemma captures the property of [branch_target]
on which the proof of semantic preservation relies. *)
Lemma branch_target_characterization:
forall f pc,
branch_target f pc = pc \/
- (exists pc', f.(fn_code)!pc = Some(Bgoto pc')
- /\ branch_target f pc' = branch_target f pc).
+ (exists pc', f.(fn_code)!pc = Some(Lnop pc')
+ /\ branch_target f pc' = branch_target f pc
+ /\ count_goto f pc' < count_goto f pc)%nat.
Proof.
intros. unfold branch_target.
generalize (branch_target_rec_1 f pc 10%nat).
@@ -67,7 +102,8 @@ Proof.
rewrite A. left; auto.
caseEq (branch_target_rec f pc 10%nat). intros pcx BT.
right. exists pc'. split. auto.
- rewrite (branch_target_rec_2 _ _ _ _ _ AT BT). auto.
+ split. rewrite (branch_target_rec_2 _ _ _ _ _ AT BT). auto.
+ unfold count_goto. eapply count_goto_rec_prop; eauto.
intro. left; auto.
Qed.
@@ -103,221 +139,233 @@ Proof.
destruct f; reflexivity.
Qed.
-(** These are inversion lemmas, characterizing what happens in the LTL
- semantics when executing [Bgoto] instructions or basic blocks. *)
-
-Lemma exec_instrs_Bgoto_inv:
- forall sp b1 ls1 m1 t b2 ls2 m2,
- exec_instrs ge sp b1 ls1 m1 t b2 ls2 m2 ->
- forall s1,
- b1 = Bgoto s1 -> t = E0 /\ b2 = b1 /\ ls2 = ls1 /\ m2 = m1.
+Lemma find_function_translated:
+ forall ros ls f,
+ find_function ge ros ls = Some f ->
+ find_function tge ros ls = Some (tunnel_fundef f).
Proof.
- induction 1.
- intros. tauto.
- intros. subst b1. inversion H.
- intros. generalize (IHexec_instrs1 s1 H2). intros [A [B [C D]]].
- subst t1 b2 rs2 m2.
- generalize (IHexec_instrs2 s1 H2). intros [A [B [C D]]].
- subst t2 b3 rs3 m3. intuition. traceEq.
+ intros until f. destruct ros; simpl.
+ intro. apply functions_translated; auto.
+ rewrite symbols_preserved. destruct (Genv.find_symbol ge i).
+ apply function_ptr_translated; auto.
+ congruence.
Qed.
-Lemma exec_block_Bgoto_inv:
- forall sp s ls1 m1 t out ls2 m2,
- exec_block ge sp (Bgoto s) ls1 m1 t out ls2 m2 ->
- t = E0 /\ out = Cont s /\ ls2 = ls1 /\ m2 = m1.
-Proof.
- intros. inversion H;
- generalize (exec_instrs_Bgoto_inv _ _ _ _ _ _ _ _ H0 s (refl_equal _));
- intros [A [B [C D]]];
- try discriminate.
- intuition congruence.
-Qed.
+(** The proof of semantic preservation is a simulation argument
+ based on diagrams of the following form:
+<<
+ st1 --------------- st2
+ | |
+ t| ?|t
+ | |
+ v v
+ st1'--------------- st2'
+>>
+ The [match_states] predicate, defined below, captures the precondition
+ between states [st1] and [st2], as well as the postcondition between
+ [st1'] and [st2']. One transition in the source code (left) can correspond
+ to zero or one transition in the transformed code (right). The
+ "zero transition" case occurs when executing a [Lgoto] instruction
+ in the source code that has been removed by tunneling.
+
+ In the definition of [match_states], note that only the control-flow
+ (in particular, the current program point [pc]) is changed:
+ the values of locations and the memory states are identical in the
+ original and transformed codes. *)
-Lemma exec_blocks_Bgoto_inv:
- forall c sp pc1 ls1 m1 t out ls2 m2 s,
- exec_blocks ge c sp pc1 ls1 m1 t out ls2 m2 ->
- c!pc1 = Some (Bgoto s) ->
- (t = E0 /\ out = Cont pc1 /\ ls2 = ls1 /\ m2 = m1)
- \/ exec_blocks ge c sp s ls1 m1 t out ls2 m2.
+Definition tunneled_code (f: function) :=
+ PTree.map (fun pc b => tunnel_instr f b) (fn_code f).
+
+Inductive match_stackframes: stackframe -> stackframe -> Prop :=
+ | match_stackframes_intro:
+ forall res f sp ls0 pc,
+ match_stackframes
+ (Stackframe res f sp ls0 pc)
+ (Stackframe res (tunnel_function f) sp ls0 (branch_target f pc)).
+
+Inductive match_states: state -> state -> Prop :=
+ | match_states_intro:
+ forall s f sp pc ls m ts,
+ list_forall2 match_stackframes s ts ->
+ match_states (State s f sp pc ls m)
+ (State ts (tunnel_function f) sp (branch_target f pc) ls m)
+ | match_states_call:
+ forall s f ls m ts,
+ list_forall2 match_stackframes s ts ->
+ match_states (Callstate s f ls m)
+ (Callstate ts (tunnel_fundef f) ls m)
+ | match_states_return:
+ forall s sig ls m ts,
+ list_forall2 match_stackframes s ts ->
+ match_states (Returnstate s sig ls m)
+ (Returnstate ts sig ls m).
+
+Lemma parent_locset_match:
+ forall s ts, list_forall2 match_stackframes s ts -> parent_locset ts = parent_locset s.
Proof.
- induction 1; intros.
- left; tauto.
- assert (b = Bgoto s). congruence. subst b.
- generalize (exec_block_Bgoto_inv _ _ _ _ _ _ _ _ H0).
- intros [A [B [C D]]]. subst t out rs' m'.
- right. apply exec_blocks_refl.
- elim (IHexec_blocks1 H2).
- intros [A [B [C D]]].
- assert (pc2 = pc1). congruence. subst t1 rs2 m2 pc2.
- replace t with t2. apply IHexec_blocks2; auto. traceEq.
- intro. right.
- eapply exec_blocks_trans; eauto.
+ induction 1; simpl; auto. inv H; auto.
Qed.
-(** The following [exec_*_prop] predicates state the correctness
- of the tunneling transformation: for each LTL execution
- in the original code (of an instruction, a sequence of instructions,
- a basic block, a sequence of basic blocks, etc), there exists
- a similar LTL execution in the tunneled code.
-
- Note that only the control-flow is changed: the values of locations
- and the memory states are identical in the original and transformed
- codes. *)
+(** To preserve non-terminating behaviours, we show that the transformed
+ code cannot take an infinity of "zero transition" cases.
+ We use the following [measure] function over source states,
+ which decreases strictly in the "zero transition" case. *)
-Definition tunnel_outcome (f: function) (out: outcome) :=
- match out with
- | Cont pc => Cont (branch_target f pc)
- | Return => Return
+Definition measure (st: state) : nat :=
+ match st with
+ | State s f sp pc ls m => count_goto f pc
+ | Callstate s f ls m => 0%nat
+ | Returnstate s sig ls m => 0%nat
end.
-Definition exec_instr_prop
- (sp: val) (b1: block) (ls1: locset) (m1: mem) (t: trace)
- (b2: block) (ls2: locset) (m2: mem) : Prop :=
- forall f,
- exec_instr tge sp (tunnel_block f b1) ls1 m1
- t (tunnel_block f b2) ls2 m2.
-
-Definition exec_instrs_prop
- (sp: val) (b1: block) (ls1: locset) (m1: mem) (t: trace)
- (b2: block) (ls2: locset) (m2: mem) : Prop :=
- forall f,
- exec_instrs tge sp (tunnel_block f b1) ls1 m1
- t (tunnel_block f b2) ls2 m2.
-
-Definition exec_block_prop
- (sp: val) (b1: block) (ls1: locset) (m1: mem) (t: trace)
- (out: outcome) (ls2: locset) (m2: mem) : Prop :=
- forall f,
- exec_block tge sp (tunnel_block f b1) ls1 m1
- t (tunnel_outcome f out) ls2 m2.
+Lemma branch_target_identity:
+ forall f pc,
+ match f.(fn_code)!pc with Some(Lnop _) => False | _ => True end ->
+ branch_target f pc = pc.
+Proof.
+ intros.
+ destruct (branch_target_characterization f pc) as [A | [pc' [B C]]].
+ auto. rewrite B in H. contradiction.
+Qed.
+
+Lemma tunnel_function_lookup:
+ forall f pc i,
+ f.(fn_code)!pc = Some i ->
+ (tunnel_function f).(fn_code)!pc = Some (tunnel_instr f i).
+Proof.
+ intros. simpl. rewrite PTree.gmap. rewrite H. auto.
+Qed.
-Definition tunneled_code (f: function) :=
- PTree.map (fun pc b => tunnel_block f b) (fn_code f).
-
-Definition exec_blocks_prop
- (c: code) (sp: val)
- (pc: node) (ls1: locset) (m1: mem) (t: trace)
- (out: outcome) (ls2: locset) (m2: mem) : Prop :=
- forall f,
- f.(fn_code) = c ->
- exec_blocks tge (tunneled_code f) sp
- (branch_target f pc) ls1 m1
- t (tunnel_outcome f out) ls2 m2.
-
-Definition exec_function_prop
- (f: fundef) (ls1: locset) (m1: mem) (t: trace)
- (ls2: locset) (m2: mem) : Prop :=
- exec_function tge (tunnel_fundef f) ls1 m1 t ls2 m2.
-
-Scheme exec_instr_ind5 := Minimality for LTL.exec_instr Sort Prop
- with exec_instrs_ind5 := Minimality for LTL.exec_instrs Sort Prop
- with exec_block_ind5 := Minimality for LTL.exec_block Sort Prop
- with exec_blocks_ind5 := Minimality for LTL.exec_blocks Sort Prop
- with exec_function_ind5 := Minimality for LTL.exec_function Sort Prop.
-
-(** The proof of semantic preservation is a structural induction
- over the LTL evaluation derivation of the original program,
- using the [exec_*_prop] predicates above as induction hypotheses. *)
-
-Lemma tunnel_function_correct:
- forall f ls1 m1 t ls2 m2,
- exec_function ge f ls1 m1 t ls2 m2 ->
- exec_function_prop f ls1 m1 t ls2 m2.
+Lemma tunnel_step_correct:
+ forall st1 t st2, step ge st1 t st2 ->
+ forall st1' (MS: match_states st1 st1'),
+ (exists st2', step tge st1' t st2' /\ match_states st2 st2')
+ \/ (measure st2 < measure st1 /\ t = E0 /\ match_states st2 st1')%nat.
Proof.
- apply (exec_function_ind5 ge
- exec_instr_prop
- exec_instrs_prop
- exec_block_prop
- exec_blocks_prop
- exec_function_prop);
- intros; red; intros; simpl.
- (* getstack *)
- constructor.
- (* setstack *)
- constructor.
- (* op *)
- constructor. rewrite <- H. apply eval_operation_preserved.
- exact symbols_preserved.
- (* load *)
- apply exec_Bload with a. rewrite <- H.
- apply eval_addressing_preserved. exact symbols_preserved.
- auto.
- (* store *)
- apply exec_Bstore with a. rewrite <- H.
- apply eval_addressing_preserved. exact symbols_preserved.
- auto.
- (* call *)
- apply exec_Bcall with (tunnel_fundef f).
- generalize H; unfold find_function; destruct ros.
- intro. apply functions_translated; auto.
- rewrite symbols_preserved. destruct (Genv.find_symbol ge i).
- intro. apply function_ptr_translated; auto. congruence.
- generalize (sig_preserved f). congruence.
- apply H2.
- (* alloc *)
- eapply exec_Balloc; eauto.
- (* instr_refl *)
- apply exec_refl.
- (* instr_one *)
- apply exec_one. apply H0.
- (* instr_trans *)
- apply exec_trans with t1 (tunnel_block f b2) rs2 m2 t2; auto.
- (* goto *)
- apply exec_Bgoto. red in H0. simpl in H0. apply H0.
- (* cond, true *)
- eapply exec_Bcond_true. red in H0. simpl in H0. apply H0. auto.
- (* cond, false *)
- eapply exec_Bcond_false. red in H0. simpl in H0. apply H0. auto.
+ induction 1; intros; try inv MS.
+ (* Lnop *)
+ destruct (branch_target_characterization f pc) as [A | [pc1 [B [C D]]]].
+ left; econstructor; split.
+ eapply exec_Lnop. rewrite A.
+ rewrite (tunnel_function_lookup _ _ _ H); simpl; auto.
+ econstructor; eauto.
+ assert (pc1 = pc') by congruence. subst pc1.
+ right. split. simpl. auto. split. auto.
+ rewrite <- C. econstructor; eauto.
+ (* Lop *)
+ rewrite (branch_target_identity f pc); [idtac | rewrite H; auto].
+ left; econstructor; split.
+ eapply exec_Lop with (v := v); eauto.
+ rewrite (tunnel_function_lookup _ _ _ H); simpl; auto.
+ rewrite <- H0. apply eval_operation_preserved. exact symbols_preserved.
+ econstructor; eauto.
+ (* Lload *)
+ rewrite (branch_target_identity f pc); [idtac | rewrite H; auto].
+ left; econstructor; split.
+ eapply exec_Lload; eauto.
+ rewrite (tunnel_function_lookup _ _ _ H); simpl; auto.
+ rewrite <- H0. apply eval_addressing_preserved. exact symbols_preserved.
+ econstructor; eauto.
+ (* Lstore *)
+ rewrite (branch_target_identity f pc); [idtac | rewrite H; auto].
+ left; econstructor; split.
+ eapply exec_Lstore; eauto.
+ rewrite (tunnel_function_lookup _ _ _ H); simpl; auto.
+ rewrite <- H0. apply eval_addressing_preserved. exact symbols_preserved.
+ econstructor; eauto.
+ (* Lcall *)
+ unfold rs1. inv MS.
+ left; econstructor; split.
+ eapply exec_Lcall with (f' := tunnel_fundef f'); eauto.
+ rewrite (branch_target_identity f pc); [idtac | rewrite H; auto].
+ rewrite (tunnel_function_lookup _ _ _ H); simpl.
+ rewrite sig_preserved. auto.
+ apply find_function_translated; auto.
+ rewrite sig_preserved; auto. fold rs1.
+ econstructor; eauto.
+ constructor; auto.
+ constructor; auto.
+ (* Ltailcall *)
+ unfold rs2, rs1 in *. inv MS. fold rs1. fold rs2.
+ left; econstructor; split.
+ eapply exec_Ltailcall with (f' := tunnel_fundef f'); eauto.
+ rewrite (branch_target_identity f pc); [idtac | rewrite H; auto].
+ rewrite (tunnel_function_lookup _ _ _ H); simpl.
+ rewrite sig_preserved. auto.
+ apply find_function_translated; auto.
+ rewrite sig_preserved; auto. fold rs1.
+ rewrite (parent_locset_match _ _ H9).
+ econstructor; eauto.
+ (* Lalloc *)
+ rewrite (branch_target_identity f pc); [idtac | rewrite H; auto].
+ left; exists (State ts (tunnel_function f) sp (branch_target f pc') rs3 m'); split.
+ unfold rs3, rs2, rs1; eapply exec_Lalloc; eauto.
+ rewrite (tunnel_function_lookup _ _ _ H); simpl; auto.
+ econstructor; eauto.
+ (* cond *)
+ rewrite (branch_target_identity f pc); [idtac | rewrite H; auto].
+ left; econstructor; split.
+ eapply exec_Lcond_true; eauto.
+ rewrite (tunnel_function_lookup _ _ _ H); simpl; eauto.
+ econstructor; eauto.
+ rewrite (branch_target_identity f pc); [idtac | rewrite H; auto].
+ left; econstructor; split.
+ eapply exec_Lcond_false; eauto.
+ rewrite (tunnel_function_lookup _ _ _ H); simpl; eauto.
+ econstructor; eauto.
(* return *)
- apply exec_Breturn. red in H0. simpl in H0. apply H0.
- (* block_refl *)
- apply exec_blocks_refl.
- (* block_one *)
- red in H1.
- elim (branch_target_characterization f pc).
- intro. rewrite H3. apply exec_blocks_one with (tunnel_block f b).
- unfold tunneled_code. rewrite PTree.gmap. rewrite H2; rewrite H.
- reflexivity. apply H1.
- intros [pc' [ATpc BTS]].
- assert (b = Bgoto pc'). congruence. subst b.
- generalize (exec_block_Bgoto_inv _ _ _ _ _ _ _ _ H0).
- intros [A [B [C D]]]. subst t out rs' m'.
- simpl. rewrite BTS. apply exec_blocks_refl.
- (* blocks_trans *)
- apply exec_blocks_trans with t1 (branch_target f pc2) rs2 m2 t2.
- exact (H0 f H4). exact (H2 f H4). auto.
+ rewrite (branch_target_identity f pc); [idtac | rewrite H; auto].
+ left; econstructor; split.
+ eapply exec_Lreturn; eauto.
+ rewrite (tunnel_function_lookup _ _ _ H); simpl; eauto.
+ simpl. rewrite (parent_locset_match _ _ H7). constructor; auto.
(* internal function *)
- econstructor. eexact H.
- change (fn_code (tunnel_function f)) with (tunneled_code f).
- simpl.
- elim (branch_target_characterization f (fn_entrypoint f)).
- intro BT. rewrite <- BT. exact (H1 f (refl_equal _)).
- intros [pc [ATpc BT]].
- apply exec_blocks_trans with
- E0 (branch_target f (fn_entrypoint f)) (call_regs rs) m1 t.
- eapply exec_blocks_one.
- unfold tunneled_code. rewrite PTree.gmap. rewrite ATpc.
- simpl. reflexivity.
- apply exec_Bgoto. rewrite BT. apply exec_refl.
- exact (H1 f (refl_equal _)). traceEq.
+ simpl. left; econstructor; split.
+ eapply exec_function_internal; eauto.
+ simpl. econstructor; eauto.
(* external function *)
- econstructor; eauto.
+ simpl. left; econstructor; split.
+ eapply exec_function_external; eauto.
+ simpl. econstructor; eauto.
+ (* return *)
+ inv H4. inv H1.
+ left; econstructor; split.
+ eapply exec_return; eauto.
+ fold rs1. constructor. auto.
Qed.
-End PRESERVATION.
+Lemma transf_initial_states:
+ forall st1, initial_state p st1 ->
+ exists st2, initial_state tp st2 /\ match_states st1 st2.
+Proof.
+ intros. inversion H.
+ exists (Callstate nil (tunnel_fundef f) (Locmap.init Vundef) (Genv.init_mem tp)); split.
+ econstructor; eauto.
+ change (prog_main tp) with (prog_main p).
+ rewrite symbols_preserved. eauto.
+ apply function_ptr_translated; auto.
+ rewrite <- H2. apply sig_preserved.
+ replace (Genv.init_mem tp) with (Genv.init_mem p).
+ constructor. constructor. auto.
+ symmetry. unfold tp, tunnel_program. apply Genv.init_mem_transf.
+Qed.
+
+Lemma transf_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 -> final_state st1 r -> final_state st2 r.
+Proof.
+ intros. inv H0. inv H. inv H6. constructor. auto.
+Qed.
Theorem transf_program_correct:
- forall (p: program) (t: trace) (r: val),
- exec_program p t r ->
- exec_program (tunnel_program p) t r.
+ forall (beh: program_behavior),
+ exec_program p beh -> exec_program tp beh.
Proof.
- intros p t r [b [f [ls [m [FIND1 [FIND2 [SIG [EX RES]]]]]]]].
- red. exists b; exists (tunnel_fundef f); exists ls; exists m.
- split. change (prog_main (tunnel_program p)) with (prog_main p).
- rewrite <- FIND1. apply symbols_preserved.
- split. apply function_ptr_translated. assumption.
- split. generalize (sig_preserved f). congruence.
- split. apply tunnel_function_correct.
- unfold tunnel_program. rewrite Genv.init_mem_transf. auto.
- rewrite sig_preserved. exact RES.
+ unfold exec_program; intros.
+ eapply simulation_opt_preservation; eauto.
+ eexact transf_initial_states.
+ eexact transf_final_states.
+ eexact tunnel_step_correct.
Qed.
+
+End PRESERVATION.
diff --git a/backend/Tunnelingtyping.v b/backend/Tunnelingtyping.v
index 6281afa1806eb7e688897cc8081d670422617ccc..c611067cd0af7cd7e22463ca962a0dad35207936 100644
--- a/backend/Tunnelingtyping.v
+++ b/backend/Tunnelingtyping.v
@@ -11,26 +11,65 @@ Require Import Locations.
Require Import LTL.
Require Import LTLtyping.
Require Import Tunneling.
+Require Import Tunnelingproof.
(** Tunneling preserves typing. *)
-Lemma wt_tunnel_block:
- forall f b,
- wt_block f b ->
- wt_block (tunnel_function f) (tunnel_block f b).
+Lemma branch_target_rec_valid:
+ forall f, wt_function f ->
+ forall count pc pc',
+ branch_target_rec f pc count = Some pc' ->
+ valid_successor f pc ->
+ valid_successor f pc'.
Proof.
- induction 1; simpl; econstructor; eauto.
+ induction count; simpl.
+ intros; discriminate.
+ intros until pc'. caseEq (is_goto_instr (fn_code f)!pc); intros.
+ generalize (is_goto_instr_correct _ _ H0). intro.
+ eapply IHcount; eauto.
+ generalize (wt_instrs _ H _ _ H3); intro WTI; inv WTI. auto.
+ inv H1; auto.
+Qed.
+
+Lemma tunnel_valid_successor:
+ forall f pc,
+ valid_successor f pc -> valid_successor (tunnel_function f) pc.
+Proof.
+ intros. destruct H as [i AT].
+ unfold valid_successor; simpl. rewrite PTree.gmap. rewrite AT.
+ simpl. exists (tunnel_instr f i); auto.
+Qed.
+
+Lemma branch_target_valid:
+ forall f pc,
+ wt_function f ->
+ valid_successor f pc ->
+ valid_successor (tunnel_function f) (branch_target f pc).
+Proof.
+ intros. apply tunnel_valid_successor.
+ unfold branch_target. caseEq (branch_target_rec f pc 10); intros.
+ eapply branch_target_rec_valid; eauto.
+ auto.
+Qed.
+
+Lemma wt_tunnel_instr:
+ forall f i,
+ wt_function f ->
+ wt_instr f i -> wt_instr (tunnel_function f) (tunnel_instr f i).
+Proof.
+ intros; inv H0; simpl; econstructor; eauto;
+ eapply branch_target_valid; eauto.
Qed.
Lemma wt_tunnel_function:
forall f, wt_function f -> wt_function (tunnel_function f).
Proof.
- unfold wt_function; intros until b.
- simpl. rewrite PTree.gmap. unfold option_map.
- caseEq (fn_code f)!pc. intros b0 AT EQ.
- injection EQ; intros; subst b.
- apply wt_tunnel_block. eauto.
- intros; discriminate.
+ intros. inversion H. constructor; simpl; auto.
+ intros until instr. rewrite PTree.gmap. unfold option_map.
+ caseEq (fn_code f)!pc. intros b0 AT EQ. inv EQ.
+ apply wt_tunnel_instr; eauto.
+ congruence.
+ eapply branch_target_valid; eauto.
Qed.
Lemma wt_tunnel_fundef:
diff --git a/caml/CMlexer.mll b/caml/CMlexer.mll
index 49d0dbdde95cf95be13a387d86ab4000bfd572c6..ae71e0c13db41764cdff2f28dd9f7ec5659bc9bd 100644
--- a/caml/CMlexer.mll
+++ b/caml/CMlexer.mll
@@ -30,8 +30,10 @@ rule token = parse
| "|" { BAR }
| "||" { BARBAR }
| "^" { CARET }
+ | "case" { CASE }
| ":" { COLON }
| "," { COMMA }
+ | "default" { DEFAULT }
| "$" { DOLLAR }
| "else" { ELSE }
| "=" { EQUAL }
@@ -75,6 +77,7 @@ rule token = parse
| "let" { LET }
| "loop" { LOOP }
| "(" { LPAREN }
+ | "match" { MATCH }
| "-" { MINUS }
| "->" { MINUSGREATER }
| "-f" { MINUSF }
diff --git a/caml/CMparser.mly b/caml/CMparser.mly
index d9a81874321d5df995fb4427631491c87b39c034..0db0af2b5dbbd04e7797113aa497881493a006f6 100644
--- a/caml/CMparser.mly
+++ b/caml/CMparser.mly
@@ -8,16 +8,67 @@ open BinPos
open BinInt
open Integers
open AST
-open Op
open Cminor
let intconst n =
- Eop(Ointconst(coqint_of_camlint n), Enil)
+ Econst(Ointconst(coqint_of_camlint n))
let andbool e1 e2 =
- Cmconstr.conditionalexpr e1 e2 (intconst 0l)
+ Econdition(e1, e2, intconst 0l)
let orbool e1 e2 =
- Cmconstr.conditionalexpr e1 (intconst 1l) e2
+ Econdition(e1, intconst 1l, e2)
+
+let exitnum n = nat_of_camlint(Int32.pred n)
+
+let mkswitch expr (cases, dfl) =
+ let rec mktable = function
+ | [] -> Coq_nil
+ | (key, exit) :: rem ->
+ Coq_cons(Coq_pair(coqint_of_camlint key, exitnum exit), mktable rem) in
+ Sswitch(expr, mktable cases, exitnum dfl)
+
+(***
+ match (a) { case 0: s0; case 1: s1; case 2: s2; } --->
+
+ block {
+ block {
+ block {
+ block {
+ switch(a) { case 0: exit 0; case 1: exit 1; default: exit 2; }
+ }; s0; exit 2;
+ }; s1; exit 1;
+ }; s2;
+ }
+
+ Note that matches are assumed to be exhaustive
+***)
+
+let mkmatch_aux expr cases =
+ let ncases = Int32.of_int (List.length cases) in
+ let rec mktable n = function
+ | [] -> assert false
+ | [key, action] -> Coq_nil
+ | (key, action) :: rem ->
+ Coq_cons(Coq_pair(coqint_of_camlint key, nat_of_camlint n),
+ mktable (Int32.succ n) rem) in
+ let sw =
+ Sswitch(expr, mktable 0l cases, nat_of_camlint (Int32.pred ncases)) in
+ let rec mkblocks body n = function
+ | [] -> assert false
+ | [key, action] ->
+ Sblock(Sseq(body, action))
+ | (key, action) :: rem ->
+ mkblocks
+ (Sblock(Sseq(body, Sseq(action, Sexit (nat_of_camlint n)))))
+ (Int32.pred n)
+ rem in
+ mkblocks (Sblock sw) (Int32.pred ncases) cases
+
+let mkmatch expr cases =
+ match cases with
+ | [] -> Sskip (* ??? *)
+ | [key, action] -> action
+ | _ -> mkmatch_aux expr cases
%}
@@ -32,8 +83,10 @@ let orbool e1 e2 =
%token BAR
%token BARBAR
%token CARET
+%token CASE
%token COLON
%token COMMA
+%token DEFAULT
%token DOLLAR
%token ELSE
%token EQUAL
@@ -81,6 +134,7 @@ let orbool e1 e2 =
%token LET
%token LOOP
%token LPAREN
+%token MATCH
%token MINUS
%token MINUSF
%token MINUSGREATER
@@ -200,7 +254,7 @@ parameter_list:
stack_declaration:
/* empty */ { Z0 }
- | STACK INTLIT { z_of_camlint $2 }
+ | STACK INTLIT SEMICOLON { z_of_camlint $2 }
;
var_declarations:
@@ -217,14 +271,18 @@ var_declaration:
stmt:
expr SEMICOLON { Sexpr $1 }
| IDENT EQUAL expr SEMICOLON { Sassign($1, $3) }
- | IF LPAREN expr RPAREN stmts ELSE stmts { Cmconstr.ifthenelse $3 $5 $7 }
- | IF LPAREN expr RPAREN stmts { Cmconstr.ifthenelse $3 $5 Sskip }
+ | IF LPAREN expr RPAREN stmts ELSE stmts { Sifthenelse($3, $5, $7) }
+ | IF LPAREN expr RPAREN stmts { Sifthenelse($3, $5, Sskip) }
| LOOP stmts { Sloop($2) }
| LBRACELBRACE stmt_list RBRACERBRACE { Sblock($2) }
| EXIT SEMICOLON { Sexit O }
- | EXIT INTLIT SEMICOLON { Sexit (nat_of_camlint(Int32.pred $2)) }
+ | EXIT INTLIT SEMICOLON { Sexit (exitnum $2) }
| RETURN SEMICOLON { Sreturn None }
| RETURN expr SEMICOLON { Sreturn (Some $2) }
+ | SWITCH LPAREN expr RPAREN LBRACE switch_cases RBRACE
+ { mkswitch $3 $6 }
+ | MATCH LPAREN expr RPAREN LBRACE match_cases RBRACE
+ { mkmatch $3 $6 }
;
stmts:
@@ -237,72 +295,84 @@ stmt_list:
| stmt stmt_list { Sseq($1, $2) }
;
+switch_cases:
+ DEFAULT COLON EXIT INTLIT SEMICOLON
+ { ([], $4) }
+ | CASE INTLIT COLON EXIT INTLIT SEMICOLON switch_cases
+ { let (cases, dfl) = $7 in (($2, $5) :: cases, dfl) }
+;
+
+match_cases:
+ /* empty */ { [] }
+ | CASE INTLIT COLON stmt_list match_cases { ($2, $4) :: $5 }
+;
+
/* Expressions */
expr:
LPAREN expr RPAREN { $2 }
| IDENT { Evar $1 }
| INTLIT { intconst $1 }
- | FLOATLIT { Eop(Ofloatconst $1, Enil) }
- | STRINGLIT { Eop(Oaddrsymbol($1, Int.zero), Enil) }
- | AMPERSAND INTLIT { Eop(Oaddrstack(coqint_of_camlint $2), Enil) }
- | MINUS expr %prec p_uminus { Cmconstr.negint $2 }
- | MINUSF expr %prec p_uminus { Cmconstr.negfloat $2 }
- | ABSF expr { Cmconstr.absfloat $2 }
- | INTOFFLOAT expr { Cmconstr.intoffloat $2 }
- | FLOATOFINT expr { Cmconstr.floatofint $2 }
- | FLOATOFINTU expr { Cmconstr.floatofintu $2 }
- | TILDE expr { Cmconstr.notint $2 }
- | BANG expr { Cmconstr.notbool $2 }
- | INT8S expr { Cmconstr.cast8signed $2 }
- | INT8U expr { Cmconstr.cast8unsigned $2 }
- | INT16S expr { Cmconstr.cast16signed $2 }
- | INT16U expr { Cmconstr.cast16unsigned $2 }
- | FLOAT32 expr { Cmconstr.singleoffloat $2 }
+ | FLOATLIT { Econst(Ofloatconst $1) }
+ | STRINGLIT { Econst(Oaddrsymbol($1, Int.zero)) }
+ | AMPERSAND INTLIT { Econst(Oaddrstack(coqint_of_camlint $2)) }
+ | MINUS expr %prec p_uminus { Eunop(Onegint, $2) }
+ | MINUSF expr %prec p_uminus { Eunop(Onegf, $2) }
+ | ABSF expr { Eunop(Oabsf, $2) }
+ | INTOFFLOAT expr { Eunop(Ointoffloat, $2) }
+ | FLOATOFINT expr { Eunop(Ofloatofint, $2) }
+ | FLOATOFINTU expr { Eunop(Ofloatofintu, $2) }
+ | TILDE expr { Eunop(Onotint, $2) }
+ | BANG expr { Eunop(Onotbool, $2) }
+ | INT8S expr { Eunop(Ocast8signed, $2) }
+ | INT8U expr { Eunop(Ocast8unsigned, $2) }
+ | INT16S expr { Eunop(Ocast16signed, $2) }
+ | INT16U expr { Eunop(Ocast16unsigned, $2) }
+ | FLOAT32 expr { Eunop(Osingleoffloat, $2) }
| ALLOC expr { Ealloc $2 }
- | expr PLUS expr { Cmconstr.add $1 $3 }
- | expr MINUS expr { Cmconstr.sub $1 $3 }
- | expr STAR expr { Cmconstr.mul $1 $3 }
- | expr SLASH expr { Cmconstr.divs $1 $3 }
- | expr PERCENT expr { Cmconstr.mods $1 $3 }
- | expr SLASHU expr { Cmconstr.divu $1 $3 }
- | expr PERCENTU expr { Cmconstr.modu $1 $3 }
- | expr AMPERSAND expr { Cmconstr.coq_and $1 $3 }
- | expr BAR expr { Cmconstr.coq_or $1 $3 }
- | expr CARET expr { Cmconstr.xor $1 $3 }
- | expr LESSLESS expr { Cmconstr.shl $1 $3 }
- | expr GREATERGREATER expr { Cmconstr.shr $1 $3 }
- | expr GREATERGREATERU expr { Cmconstr.shru $1 $3 }
- | expr PLUSF expr { Cmconstr.addf $1 $3 }
- | expr MINUSF expr { Cmconstr.subf $1 $3 }
- | expr STARF expr { Cmconstr.mulf $1 $3 }
- | expr SLASHF expr { Cmconstr.divf $1 $3 }
- | expr EQUALEQUAL expr { Cmconstr.cmp Ceq $1 $3 }
- | expr BANGEQUAL expr { Cmconstr.cmp Cne $1 $3 }
- | expr LESS expr { Cmconstr.cmp Clt $1 $3 }
- | expr LESSEQUAL expr { Cmconstr.cmp Cle $1 $3 }
- | expr GREATER expr { Cmconstr.cmp Cgt $1 $3 }
- | expr GREATEREQUAL expr { Cmconstr.cmp Cge $1 $3 }
- | expr EQUALEQUALU expr { Cmconstr.cmpu Ceq $1 $3 }
- | expr BANGEQUALU expr { Cmconstr.cmpu Cne $1 $3 }
- | expr LESSU expr { Cmconstr.cmpu Clt $1 $3 }
- | expr LESSEQUALU expr { Cmconstr.cmpu Cle $1 $3 }
- | expr GREATERU expr { Cmconstr.cmpu Cgt $1 $3 }
- | expr GREATEREQUALU expr { Cmconstr.cmpu Cge $1 $3 }
- | expr EQUALEQUALF expr { Cmconstr.cmpf Ceq $1 $3 }
- | expr BANGEQUALF expr { Cmconstr.cmpf Cne $1 $3 }
- | expr LESSF expr { Cmconstr.cmpf Clt $1 $3 }
- | expr LESSEQUALF expr { Cmconstr.cmpf Cle $1 $3 }
- | expr GREATERF expr { Cmconstr.cmpf Cgt $1 $3 }
- | expr GREATEREQUALF expr { Cmconstr.cmpf Cge $1 $3 }
- | memory_chunk LBRACKET expr RBRACKET { Cmconstr.load $1 $3 }
+ | expr PLUS expr { Ebinop(Oadd, $1, $3) }
+ | expr MINUS expr { Ebinop(Osub, $1, $3) }
+ | expr STAR expr { Ebinop(Omul, $1, $3) }
+ | expr SLASH expr { Ebinop(Odiv, $1, $3) }
+ | expr PERCENT expr { Ebinop(Omod, $1, $3) }
+ | expr SLASHU expr { Ebinop(Odivu, $1, $3) }
+ | expr PERCENTU expr { Ebinop(Omodu, $1, $3) }
+ | expr AMPERSAND expr { Ebinop(Oand, $1, $3) }
+ | expr BAR expr { Ebinop(Oor, $1, $3) }
+ | expr CARET expr { Ebinop(Oxor, $1, $3) }
+ | expr LESSLESS expr { Ebinop(Oshl, $1, $3) }
+ | expr GREATERGREATER expr { Ebinop(Oshr, $1, $3) }
+ | expr GREATERGREATERU expr { Ebinop(Oshru, $1, $3) }
+ | expr PLUSF expr { Ebinop(Oaddf, $1, $3) }
+ | expr MINUSF expr { Ebinop(Osubf, $1, $3) }
+ | expr STARF expr { Ebinop(Omulf, $1, $3) }
+ | expr SLASHF expr { Ebinop(Odivf, $1, $3) }
+ | expr EQUALEQUAL expr { Ebinop(Ocmp Ceq, $1, $3) }
+ | expr BANGEQUAL expr { Ebinop(Ocmp Cne, $1, $3) }
+ | expr LESS expr { Ebinop(Ocmp Clt, $1, $3) }
+ | expr LESSEQUAL expr { Ebinop(Ocmp Cle, $1, $3) }
+ | expr GREATER expr { Ebinop(Ocmp Cgt, $1, $3) }
+ | expr GREATEREQUAL expr { Ebinop(Ocmp Cge, $1, $3) }
+ | expr EQUALEQUALU expr { Ebinop(Ocmpu Ceq, $1, $3) }
+ | expr BANGEQUALU expr { Ebinop(Ocmpu Cne, $1, $3) }
+ | expr LESSU expr { Ebinop(Ocmpu Clt, $1, $3) }
+ | expr LESSEQUALU expr { Ebinop(Ocmpu Cle, $1, $3) }
+ | expr GREATERU expr { Ebinop(Ocmpu Cgt, $1, $3) }
+ | expr GREATEREQUALU expr { Ebinop(Ocmpu Cge, $1, $3) }
+ | expr EQUALEQUALF expr { Ebinop(Ocmpf Ceq, $1, $3) }
+ | expr BANGEQUALF expr { Ebinop(Ocmpf Cne, $1, $3) }
+ | expr LESSF expr { Ebinop(Ocmpf Clt, $1, $3) }
+ | expr LESSEQUALF expr { Ebinop(Ocmpf Cle, $1, $3) }
+ | expr GREATERF expr { Ebinop(Ocmpf Cgt, $1, $3) }
+ | expr GREATEREQUALF expr { Ebinop(Ocmpf Cge, $1, $3) }
+ | memory_chunk LBRACKET expr RBRACKET { Eload($1, $3) }
| memory_chunk LBRACKET expr RBRACKET EQUAL expr
- { Cmconstr.store $1 $3 $6 }
+ { Estore($1, $3, $6) }
| expr LPAREN expr_list RPAREN COLON signature
{ Ecall($6, $1, $3) }
| expr AMPERSANDAMPERSAND expr { andbool $1 $3 }
| expr BARBAR expr { orbool $1 $3 }
- | expr QUESTION expr COLON expr { Cmconstr.conditionalexpr $1 $3 $5 }
+ | expr QUESTION expr COLON expr { Econdition($1, $3, $5) }
| LET expr IN expr %prec p_let { Elet($2, $4) }
| DOLLAR INTLIT { Eletvar (nat_of_camlint $2) }
;
diff --git a/caml/CMtypecheck.ml b/caml/CMtypecheck.ml
index a926039dc40958e70232cfb10c516e7b1b2803ec..495ded0cf1c5264bdf3bce270e5ca3bbe4b9afbd 100644
--- a/caml/CMtypecheck.ml
+++ b/caml/CMtypecheck.ml
@@ -6,7 +6,6 @@ open CList
open Camlcoq
open AST
open Integers
-open Op
open Cminor
exception Error of string
@@ -67,135 +66,91 @@ let name_of_comparison = function
| Cgt -> "gt"
| Cge -> "ge"
-let type_condition = function
- | Ccomp _ -> [tint;tint]
- | Ccompu _ -> [tint;tint]
- | Ccompimm _ -> [tint]
- | Ccompuimm _ -> [tint]
- | Ccompf _ -> [tfloat;tfloat]
- | Cnotcompf _ -> [tfloat;tfloat]
- | Cmaskzero _ -> [tint]
- | Cmasknotzero _ -> [tint]
+let type_constant = function
+ | Ointconst _ -> tint
+ | Ofloatconst _ -> tfloat
+ | Oaddrsymbol _ -> tint
+ | Oaddrstack _ -> tint
-let name_of_condition = function
- | Ccomp c -> sprintf "comp %s" (name_of_comparison c)
- | Ccompu c -> sprintf "compu %s" (name_of_comparison c)
- | Ccompimm(c, n) -> sprintf "compimm %s %ld" (name_of_comparison c) (camlint_of_coqint n)
- | Ccompuimm(c, n) -> sprintf "compuimm %s %ld" (name_of_comparison c) (camlint_of_coqint n)
- | Ccompf c -> sprintf "compf %s" (name_of_comparison c)
- | Cnotcompf c -> sprintf "notcompf %s" (name_of_comparison c)
- | Cmaskzero n -> sprintf "maskzero %ld" (camlint_of_coqint n)
- | Cmasknotzero n -> sprintf "masknotzero %ld" (camlint_of_coqint n)
+let type_unary_operation = function
+ | Ocast8signed -> tint, tint
+ | Ocast16signed -> tint, tint
+ | Ocast8unsigned -> tint, tint
+ | Ocast16unsigned -> tint, tint
+ | Onegint -> tint, tint
+ | Onotbool -> tint, tint
+ | Onotint -> tint, tint
+ | Onegf -> tfloat, tfloat
+ | Oabsf -> tfloat, tfloat
+ | Osingleoffloat -> tfloat, tfloat
+ | Ointoffloat -> tfloat, tint
+ | Ofloatofint -> tint, tfloat
+ | Ofloatofintu -> tint, tfloat
-let type_operation = function
- | Omove -> let v = newvar() in [v], v
- | Ointconst _ -> [], tint
- | Ofloatconst _ -> [], tfloat
- | Oaddrsymbol _ -> [], tint
- | Oaddrstack _ -> [], tint
- | Oundef -> [], newvar()
- | Ocast8signed -> [tint], tint
- | Ocast16signed -> [tint], tint
- | Ocast8unsigned -> [tint], tint
- | Ocast16unsigned -> [tint], tint
- | Oadd -> [tint;tint], tint
- | Oaddimm _ -> [tint], tint
- | Osub -> [tint;tint], tint
- | Osubimm _ -> [tint], tint
- | Omul -> [tint;tint], tint
- | Omulimm _ -> [tint], tint
- | Odiv -> [tint;tint], tint
- | Odivu -> [tint;tint], tint
- | Oand -> [tint;tint], tint
- | Oandimm _ -> [tint], tint
- | Oor -> [tint;tint], tint
- | Oorimm _ -> [tint], tint
- | Oxor -> [tint;tint], tint
- | Oxorimm _ -> [tint], tint
- | Onand -> [tint;tint], tint
- | Onor -> [tint;tint], tint
- | Onxor -> [tint;tint], tint
- | Oshl -> [tint;tint], tint
- | Oshr -> [tint;tint], tint
- | Oshrimm _ -> [tint], tint
- | Oshrximm _ -> [tint], tint
- | Oshru -> [tint;tint], tint
- | Orolm _ -> [tint], tint
- | Onegf -> [tfloat], tfloat
- | Oabsf -> [tfloat], tfloat
- | Oaddf -> [tfloat;tfloat], tfloat
- | Osubf -> [tfloat;tfloat], tfloat
- | Omulf -> [tfloat;tfloat], tfloat
- | Odivf -> [tfloat;tfloat], tfloat
- | Omuladdf -> [tfloat;tfloat;tfloat], tfloat
- | Omulsubf -> [tfloat;tfloat;tfloat], tfloat
- | Osingleoffloat -> [tfloat], tfloat
- | Ointoffloat -> [tfloat], tint
- | Ofloatofint -> [tint], tfloat
- | Ofloatofintu -> [tint], tfloat
- | Ocmp c -> type_condition c, tint
+let type_binary_operation = function
+ | Oadd -> tint, tint, tint
+ | Osub -> tint, tint, tint
+ | Omul -> tint, tint, tint
+ | Odiv -> tint, tint, tint
+ | Odivu -> tint, tint, tint
+ | Omod -> tint, tint, tint
+ | Omodu -> tint, tint, tint
+ | Oand -> tint, tint, tint
+ | Oor -> tint, tint, tint
+ | Oxor -> tint, tint, tint
+ | Oshl -> tint, tint, tint
+ | Oshr -> tint, tint, tint
+ | Oshru -> tint, tint, tint
+ | Oaddf -> tfloat, tfloat, tfloat
+ | Osubf -> tfloat, tfloat, tfloat
+ | Omulf -> tfloat, tfloat, tfloat
+ | Odivf -> tfloat, tfloat, tfloat
+ | Ocmp _ -> tint, tint, tint
+ | Ocmpu _ -> tint, tint, tint
+ | Ocmpf _ -> tfloat, tfloat, tint
-let name_of_operation = function
- | Omove -> "move"
+let name_of_constant = function
| Ointconst n -> sprintf "intconst %ld" (camlint_of_coqint n)
| Ofloatconst n -> sprintf "floatconst %g" n
| Oaddrsymbol (s, ofs) -> sprintf "addrsymbol %s %ld" (extern_atom s) (camlint_of_coqint ofs)
| Oaddrstack n -> sprintf "addrstack %ld" (camlint_of_coqint n)
- | Oundef -> "undef"
+
+let name_of_unary_operation = function
| Ocast8signed -> "cast8signed"
| Ocast16signed -> "cast16signed"
| Ocast8unsigned -> "cast8unsigned"
| Ocast16unsigned -> "cast16unsigned"
+ | Onegint -> "negint"
+ | Onotbool -> "notbool"
+ | Onotint -> "notint"
+ | Onegf -> "negf"
+ | Oabsf -> "absf"
+ | Osingleoffloat -> "singleoffloat"
+ | Ointoffloat -> "intoffloat"
+ | Ofloatofint -> "floatofint"
+ | Ofloatofintu -> "floatofintu"
+
+let name_of_binary_operation = function
| Oadd -> "add"
- | Oaddimm n -> sprintf "addimm %ld" (camlint_of_coqint n)
| Osub -> "sub"
- | Osubimm n -> sprintf "subimm %ld" (camlint_of_coqint n)
| Omul -> "mul"
- | Omulimm n -> sprintf "mulimm %ld" (camlint_of_coqint n)
| Odiv -> "div"
| Odivu -> "divu"
+ | Omod -> "mod"
+ | Omodu -> "modu"
| Oand -> "and"
- | Oandimm n -> sprintf "andimm %ld" (camlint_of_coqint n)
| Oor -> "or"
- | Oorimm n -> sprintf "orimm %ld" (camlint_of_coqint n)
| Oxor -> "xor"
- | Oxorimm n -> sprintf "xorimm %ld" (camlint_of_coqint n)
- | Onand -> "nand"
- | Onor -> "nor"
- | Onxor -> "nxor"
| Oshl -> "shl"
| Oshr -> "shr"
- | Oshrimm n -> sprintf "shrimm %ld" (camlint_of_coqint n)
- | Oshrximm n -> sprintf "shrximm %ld" (camlint_of_coqint n)
| Oshru -> "shru"
- | Orolm(n, m) -> sprintf "rolm %ld %ld" (camlint_of_coqint n) (camlint_of_coqint m)
- | Onegf -> "negf"
- | Oabsf -> "absf"
| Oaddf -> "addf"
| Osubf -> "subf"
| Omulf -> "mulf"
| Odivf -> "divf"
- | Omuladdf -> "muladdf"
- | Omulsubf -> "mulsubf"
- | Osingleoffloat -> "singleoffloat"
- | Ointoffloat -> "intoffloat"
- | Ofloatofint -> "floatofint"
- | Ofloatofintu -> "floatofintu"
- | Ocmp c -> name_of_condition c
-
-let type_addressing = function
- | Aindexed _ -> [tint]
- | Aindexed2 -> [tint;tint]
- | Aglobal _ -> []
- | Abased _ -> [tint]
- | Ainstack _ -> []
-
-let name_of_addressing = function
- | Aindexed n -> sprintf "indexed %ld" (camlint_of_coqint n)
- | Aindexed2 -> sprintf "indexed2"
- | Aglobal(s, ofs) -> sprintf "global %s %ld" (extern_atom s) (camlint_of_coqint ofs)
- | Abased(s, ofs) -> sprintf "based %s %ld" (extern_atom s) (camlint_of_coqint ofs)
- | Ainstack n -> sprintf "instack %ld" (camlint_of_coqint n)
+ | Ocmp c -> sprintf "cmp %s" (name_of_comparison c)
+ | Ocmpu c -> sprintf "cmpu %s" (name_of_comparison c)
+ | Ocmpf c -> sprintf "cmpf %s" (name_of_comparison c)
let type_chunk = function
| Mint8signed -> tint
@@ -219,34 +174,47 @@ let rec type_expr env lenv e =
match e with
| Evar id ->
type_var env id
- | Eop(op, el) ->
- let tel = type_exprlist env lenv el in
- let (targs, tres) = type_operation op in
+ | Econst cst ->
+ type_constant cst
+ | Eunop(op, e1) ->
+ let te1 = type_expr env lenv e1 in
+ let (targ, tres) = type_unary_operation op in
begin try
- unify_list targs tel
+ unify targ te1
with Error s ->
raise (Error (sprintf "In application of operator %s:\n%s"
- (name_of_operation op) s))
+ (name_of_unary_operation op) s))
end;
tres
- | Eload(chunk, addr, el) ->
- let tel = type_exprlist env lenv el in
+ | Ebinop(op, e1, e2) ->
+ let te1 = type_expr env lenv e1 in
+ let te2 = type_expr env lenv e2 in
+ let (targ1, targ2, tres) = type_binary_operation op in
begin try
- unify_list (type_addressing addr) tel
+ unify targ1 te1; unify targ2 te2
with Error s ->
- raise (Error (sprintf "In load %s %s:\n%s"
- (name_of_chunk chunk) (name_of_addressing addr) s))
+ raise (Error (sprintf "In application of operator %s:\n%s"
+ (name_of_binary_operation op) s))
+ end;
+ tres
+ | Eload(chunk, e) ->
+ let te = type_expr env lenv e in
+ begin try
+ unify tint te
+ with Error s ->
+ raise (Error (sprintf "In load %s:\n%s"
+ (name_of_chunk chunk) s))
end;
type_chunk chunk
- | Estore(chunk, addr, el, e1) ->
- let tel = type_exprlist env lenv el in
+ | Estore(chunk, e1, e2) ->
let te1 = type_expr env lenv e1 in
+ let te2 = type_expr env lenv e2 in
begin try
- unify_list (type_addressing addr) tel;
- unify (type_chunk chunk) te1
+ unify tint te1;
+ unify (type_chunk chunk) te2
with Error s ->
- raise (Error (sprintf "In store %s %s:\n%s"
- (name_of_chunk chunk) (name_of_addressing addr) s))
+ raise (Error (sprintf "In store %s:\n%s"
+ (name_of_chunk chunk) s))
end;
te1
| Ecall(sg, e1, el) ->
@@ -295,21 +263,13 @@ and type_exprlist env lenv el =
let tet = type_exprlist env lenv et in
(te1 :: tet)
-and type_condexpr env lenv ce =
- match ce with
- | CEtrue -> ()
- | CEfalse -> ()
- | CEcond(c, el) ->
- let tel = type_exprlist env lenv el in
- begin try
- unify_list (type_condition c) tel
- with Error s ->
- raise (Error (sprintf "In condition %s:\n%s" (name_of_condition c) s))
- end
- | CEcondition(ce1, ce2, ce3) ->
- type_condexpr env lenv ce1;
- type_condexpr env lenv ce2;
- type_condexpr env lenv ce3
+and type_condexpr env lenv e =
+ let te = type_expr env lenv e in
+ begin try
+ unify tint te
+ with Error s ->
+ raise (Error (sprintf "In condition:\n%s" s))
+ end
let rec type_stmt env blk ret s =
match s with
@@ -355,6 +315,15 @@ let rec type_stmt env blk ret s =
raise (Error (sprintf "In return:\n%s" s))
end
end
+ | Stailcall(sg, e1, el) ->
+ let te1 = type_expr env [] e1 in
+ let tel = type_exprlist env [] el in
+ begin try
+ unify tint te1;
+ unify_list (ty_of_sig_args sg.sig_args) tel
+ with Error s ->
+ raise (Error (sprintf "In tail call:\n%s" s))
+ end
let rec env_of_vars idl =
match idl with
diff --git a/caml/Camlcoq.ml b/caml/Camlcoq.ml
index c2115dfb0fd84fb0141ff6ad049d27aef375518f..ec2447fa2fd5acdf5e681b707a593cf437216833 100644
--- a/caml/Camlcoq.ml
+++ b/caml/Camlcoq.ml
@@ -41,7 +41,7 @@ let z_of_camlint n =
let coqint_of_camlint : int32 -> Integers.int = z_of_camlint
-(* Strings *)
+(* Atoms (positive integers representing strings) *)
let atom_of_string = (Hashtbl.create 17 : (string, positive) Hashtbl.t)
let string_of_atom = (Hashtbl.create 17 : (positive, string) Hashtbl.t)
@@ -69,24 +69,6 @@ let rec coqlist_iter f = function
Coq_nil -> ()
| Coq_cons(a,l) -> f a; coqlist_iter f l
-(* Helpers *)
-
-let rec list_iter f = function
- [] -> ()
- | a::l -> f a; list_iter f l
-
-let rec list_memq x = function
- [] -> false
- | a::l -> a == x || list_memq x l
-
-let rec list_exists p = function
- [] -> false
- | a::l -> p a || list_exists p l
-
-let rec list_filter p = function
- [] -> []
- | x :: l -> if p x then x :: list_filter p l else list_filter p l
-
let rec length_coqlist = function
| Coq_nil -> 0
| Coq_cons (x, l) -> 1 + length_coqlist l
@@ -100,6 +82,31 @@ let array_of_coqlist = function
| Coq_cons(hd, tl) -> a.(i) <- hd; fill (i + 1) tl in
fill 1 tl
+(* Strings *)
+
+let char_of_ascii (Ascii.Ascii(a0, a1, a2, a3, a4, a5, a6, a7)) =
+ Char.chr( (if a0 then 1 else 0)
+ + (if a1 then 2 else 0)
+ + (if a2 then 4 else 0)
+ + (if a3 then 8 else 0)
+ + (if a4 then 16 else 0)
+ + (if a5 then 32 else 0)
+ + (if a6 then 64 else 0)
+ + (if a7 then 128 else 0))
+
+let coqstring_length s =
+ let rec len accu = function
+ | CString.EmptyString -> accu
+ | CString.CString(_, s) -> len (accu + 1) s
+ in len 0 s
+
+let camlstring_of_coqstring s =
+ let r = String.create (coqstring_length s) in
+ let rec fill pos = function
+ | CString.EmptyString -> r
+ | CString.CString(c, s) -> r.[pos] <- char_of_ascii c; fill (pos + 1) s
+ in fill 0 s
+
(* Timing facility *)
(*
diff --git a/caml/Coloringaux.ml b/caml/Coloringaux.ml
index a7c8db5c83e128a479339fa787618983b1a82698..b3f4515e91b7b80344fc613a0141a3835068492f 100644
--- a/caml/Coloringaux.ml
+++ b/caml/Coloringaux.ml
@@ -185,8 +185,8 @@ let init() =
let interfere n1 n2 =
if n1.degree < n2.degree
- then list_memq n2 n1.adjlist
- else list_memq n1 n2.adjlist
+ then List.memq n2 n1.adjlist
+ else List.memq n1 n2.adjlist
(* Add an edge to the graph. Assume edge is not in graph already *)
@@ -199,7 +199,7 @@ let addEdge n1 n2 =
(* Apply the given function to the relevant adjacent nodes of a node *)
let iterAdjacent f n =
- list_iter
+ List.iter
(fun n ->
match n.nstate with
| SelectStack | CoalescedNodes -> ()
@@ -214,12 +214,12 @@ let moveIsActiveOrWorklist m =
| _ -> false
let nodeMoves n =
- list_filter moveIsActiveOrWorklist n.movelist
+ List.filter moveIsActiveOrWorklist n.movelist
(* Determine whether a node is involved in a move *)
let moveRelated n =
- list_exists moveIsActiveOrWorklist n.movelist
+ List.exists moveIsActiveOrWorklist n.movelist
(*i
(* Check invariants *)
@@ -361,7 +361,7 @@ let build g typenv spillcosts =
(* Enable moves that have become low-degree related *)
let enableMoves n =
- list_iter
+ List.iter
(fun m ->
if m.mstate = ActiveMoves
then DLinkMove.move m activeMoves worklistMoves)
@@ -481,7 +481,7 @@ let freezeMoves u =
&& v.degree < num_available_registers.(v.regclass)
&& v.nstate <> Colored
then DLinkNode.move v freezeWorklist simplifyWorklist in
- list_iter freeze (nodeMoves u)
+ List.iter freeze (nodeMoves u)
(* Pick a move and freeze it *)
@@ -577,7 +577,7 @@ let find_slot conflicts typ =
let assign_color n =
let conflicts = ref Locset.empty in
- list_iter
+ List.iter
(fun n' ->
match (getAlias n').color with
| None -> ()
@@ -607,7 +607,7 @@ let graph_coloring (f: coq_function) (g: graph) (env: regenv) (regs: Regset.t)
init();
Array.fill start_points 0 num_register_classes 0;
let mapping = build g env (spill_costs f) in
- list_iter assign_color (nodeOrder []);
+ List.iter assign_color (nodeOrder []);
fun r ->
try location_of_node (getAlias (Hashtbl.find mapping r))
with Not_found -> R IT1 (* any location *)
diff --git a/caml/Main2.ml b/caml/Main2.ml
index ff9f3509cf4321eedcf84b680c6e2bb1c2620fde..e3399fb99e840ec8f991da30bde0cc3946c6a0c1 100644
--- a/caml/Main2.ml
+++ b/caml/Main2.ml
@@ -94,8 +94,8 @@ let process_c_file sourcename =
(* Convert to PPC *)
let ppc =
match Main.transf_c_program csyntax with
- | Datatypes.Some x -> x
- | Datatypes.None ->
+ | Errors.OK x -> x
+ | Errors.Error msg ->
eprintf "Error in translation Csyntax -> PPC\n";
exit 2 in
(* Save PPC asm *)
@@ -111,10 +111,10 @@ let process_cminor_file sourcename =
match Main.transf_cminor_program
(CMtypecheck.type_program
(CMparser.prog CMlexer.token lb)) with
- | Datatypes.None ->
+ | Errors.Error msg ->
eprintf "Compiler failure\n";
exit 2
- | Datatypes.Some p ->
+ | Errors.OK p ->
let oc = open_out targetname in
PrintPPC.print_program oc p;
close_out oc
diff --git a/caml/PrintPPC.ml b/caml/PrintPPC.ml
index 3ee79d127790494c49340d27265a1034c7eacf1a..bf7b2cc74ee9e5b7e789342b48e9c5f42379ae08 100644
--- a/caml/PrintPPC.ml
+++ b/caml/PrintPPC.ml
@@ -137,6 +137,8 @@ let print_instruction oc labels = function
fprintf oc " bf %a, %a\n" print_crbit bit print_label lbl
| Pbl s ->
fprintf oc " bl %a\n" print_symb s
+ | Pbs s ->
+ fprintf oc " b %a\n" print_symb s
| Pblr ->
fprintf oc " blr\n"
| Pbt(bit, lbl) ->
@@ -318,10 +320,6 @@ let print_instruction oc labels = function
fprintf oc " xoris %a, %a, %a\n" ireg r1 ireg r2 print_constant c
| Plabel lbl ->
if Labelset.mem lbl labels then fprintf oc "%a:\n" print_label lbl
- | Piundef r ->
- fprintf oc " # undef %a\n" ireg r
- | Pfundef r ->
- fprintf oc " # undef %a\n" freg r
let rec labels_of_code = function
| Coq_nil -> Labelset.empty
diff --git a/caml/RTLgenaux.ml b/caml/RTLgenaux.ml
index 336346afdb529a6873a73b211e52fb633ac63527..61abecfa06f36ceeb3a5840972a9a67a26a3bf87 100644
--- a/caml/RTLgenaux.ml
+++ b/caml/RTLgenaux.ml
@@ -1,3 +1,47 @@
-open Cminor
+open Switch
+open CminorSel
let more_likely (c: condexpr) (ifso: stmt) (ifnot: stmt) = false
+
+module IntOrd =
+ struct
+ type t = Integers.int
+ let compare x y =
+ if Integers.Int.eq x y then 0 else
+ if Integers.Int.ltu x y then -1 else 1
+ end
+
+module IntSet = Set.Make(IntOrd)
+
+let normalize_table tbl =
+ let rec norm seen = function
+ | CList.Coq_nil -> []
+ | CList.Coq_cons(Datatypes.Coq_pair(key, act), rem) ->
+ if IntSet.mem key seen
+ then norm seen rem
+ else (key, act) :: norm (IntSet.add key seen) rem
+ in norm IntSet.empty tbl
+
+let compile_switch default table =
+ let sw = Array.of_list (normalize_table table) in
+ Array.stable_sort (fun (n1, _) (n2, _) -> IntOrd.compare n1 n2) sw;
+ let rec build lo hi =
+ match hi - lo with
+ | 0 ->
+ CTaction default
+ | 1 ->
+ CTifeq(fst sw.(lo), snd sw.(lo), CTaction default)
+ | 2 ->
+ CTifeq(fst sw.(lo), snd sw.(lo),
+ CTifeq(fst sw.(lo+1), snd sw.(lo+1),
+ CTaction default))
+ | 3 ->
+ CTifeq(fst sw.(lo), snd sw.(lo),
+ CTifeq(fst sw.(lo+1), snd sw.(lo+1),
+ CTifeq(fst sw.(lo+2), snd sw.(lo+2),
+ CTaction default)))
+ | _ ->
+ let mid = (lo + hi) / 2 in
+ CTiflt(fst sw.(mid), build lo mid, build mid hi)
+ in build 0 (Array.length sw)
+
diff --git a/caml/RTLtypingaux.ml b/caml/RTLtypingaux.ml
index 64f839a2f47917f5f5fa1dff3a24dbca0de8e475..5ed7e6e25da92b6d0f2515ab4edbe7342a8868cd 100644
--- a/caml/RTLtypingaux.ml
+++ b/caml/RTLtypingaux.ml
@@ -32,10 +32,6 @@ let type_instr retty (Coq_pair(pc, i)) =
()
| Iop(Omove, _, _, _) ->
()
- | Iop(Oundef, Coq_nil, res, _) ->
- ()
- | Iop(Oundef, _, _, _) ->
- raise (Type_error "wrong Oundef")
| Iop(op, args, res, _) ->
let (Coq_pair(targs, tres)) = type_of_operation op in
set_types args targs; set_type res tres
@@ -61,6 +57,23 @@ let type_instr retty (Coq_pair(pc, i)) =
raise(Type_error (Printf.sprintf "type mismatch in Icall(%s): %s"
name msg))
end
+ | Itailcall(sg, ros, args) ->
+ begin try
+ begin match ros with
+ | Coq_inl r -> set_type r Tint
+ | Coq_inr _ -> ()
+ end;
+ set_types args sg.sig_args;
+ if sg.sig_res <> retty then
+ raise (Type_error "mismatch on return type")
+ with Type_error msg ->
+ let name =
+ match ros with
+ | Coq_inl _ -> "<reg>"
+ | Coq_inr id -> extern_atom id in
+ raise(Type_error (Printf.sprintf "type mismatch in Itailcall(%s): %s"
+ name msg))
+ end
| Ialloc(arg, res, _) ->
set_type arg Tint; set_type res Tint
| Icond(cond, args, _, _) ->
diff --git a/cfrontend/Cminorgen.v b/cfrontend/Cminorgen.v
index a3afae2057fb79ce35f1a8360d07e433842cc17a..23faf785a1ded0801f9a7dbf4c1dbe227773be9e 100644
--- a/cfrontend/Cminorgen.v
+++ b/cfrontend/Cminorgen.v
@@ -3,6 +3,7 @@
Require Import FSets.
Require FSetAVL.
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import Ordered.
Require Import AST.
@@ -11,7 +12,9 @@ Require Mem.
Require Import Csharpminor.
Require Import Op.
Require Import Cminor.
-Require Cmconstr.
+
+Open Local Scope string_scope.
+Open Local Scope error_monad_scope.
(** The main task in translating Csharpminor to Cminor is to explicitly
stack-allocate local variables whose address is taken: these local
@@ -35,57 +38,12 @@ Require Cmconstr.
the ``normalize at assignment-time'' semantics of Csharpminor.
*)
-(** Translation of operators. *)
+(** Translation of constants. *)
-Definition make_op (op: Csharpminor.operation) (el: exprlist): option expr :=
- match el with
- | Enil =>
- match op with
- | Csharpminor.Ointconst n => Some(Eop (Ointconst n) Enil)
- | Csharpminor.Ofloatconst n => Some(Eop (Ofloatconst n) Enil)
- | _ => None
- end
- | Econs e1 Enil =>
- match op with
- | Csharpminor.Ocast8unsigned => Some(Cmconstr.cast8unsigned e1)
- | Csharpminor.Ocast8signed => Some(Cmconstr.cast8signed e1)
- | Csharpminor.Ocast16unsigned => Some(Cmconstr.cast16unsigned e1)
- | Csharpminor.Ocast16signed => Some(Cmconstr.cast16signed e1)
- | Csharpminor.Onotint => Some(Cmconstr.notint e1)
- | Csharpminor.Onotbool => Some(Cmconstr.notbool e1)
- | Csharpminor.Onegf => Some(Cmconstr.negfloat e1)
- | Csharpminor.Oabsf => Some(Cmconstr.absfloat e1)
- | Csharpminor.Osingleoffloat => Some(Cmconstr.singleoffloat e1)
- | Csharpminor.Ointoffloat => Some(Cmconstr.intoffloat e1)
- | Csharpminor.Ofloatofint => Some(Cmconstr.floatofint e1)
- | Csharpminor.Ofloatofintu => Some(Cmconstr.floatofintu e1)
- | _ => None
- end
- | Econs e1 (Econs e2 Enil) =>
- match op with
- | Csharpminor.Oadd => Some(Cmconstr.add e1 e2)
- | Csharpminor.Osub => Some(Cmconstr.sub e1 e2)
- | Csharpminor.Omul => Some(Cmconstr.mul e1 e2)
- | Csharpminor.Odiv => Some(Cmconstr.divs e1 e2)
- | Csharpminor.Odivu => Some(Cmconstr.divu e1 e2)
- | Csharpminor.Omod => Some(Cmconstr.mods e1 e2)
- | Csharpminor.Omodu => Some(Cmconstr.modu e1 e2)
- | Csharpminor.Oand => Some(Cmconstr.and e1 e2)
- | Csharpminor.Oor => Some(Cmconstr.or e1 e2)
- | Csharpminor.Oxor => Some(Cmconstr.xor e1 e2)
- | Csharpminor.Oshl => Some(Cmconstr.shl e1 e2)
- | Csharpminor.Oshr => Some(Cmconstr.shr e1 e2)
- | Csharpminor.Oshru => Some(Cmconstr.shru e1 e2)
- | Csharpminor.Oaddf => Some(Cmconstr.addf e1 e2)
- | Csharpminor.Osubf => Some(Cmconstr.subf e1 e2)
- | Csharpminor.Omulf => Some(Cmconstr.mulf e1 e2)
- | Csharpminor.Odivf => Some(Cmconstr.divf e1 e2)
- | Csharpminor.Ocmp c => Some(Cmconstr.cmp c e1 e2)
- | Csharpminor.Ocmpu c => Some(Cmconstr.cmpu c e1 e2)
- | Csharpminor.Ocmpf c => Some(Cmconstr.cmpf c e1 e2)
- | _ => None
- end
- | _ => None
+Definition transl_constant (cst: Csharpminor.constant): constant :=
+ match cst with
+ | Csharpminor.Ointconst n => Ointconst n
+ | Csharpminor.Ofloatconst n => Ofloatconst n
end.
(** [make_cast chunk e] returns a Cminor expression that normalizes
@@ -95,45 +53,38 @@ Definition make_op (op: Csharpminor.operation) (el: exprlist): option expr :=
Definition make_cast (chunk: memory_chunk) (e: expr): expr :=
match chunk with
- | Mint8signed => Cmconstr.cast8signed e
- | Mint8unsigned => Cmconstr.cast8unsigned e
- | Mint16signed => Cmconstr.cast16signed e
- | Mint16unsigned => Cmconstr.cast16unsigned e
+ | Mint8signed => Eunop Ocast8signed e
+ | Mint8unsigned => Eunop Ocast8unsigned e
+ | Mint16signed => Eunop Ocast16signed e
+ | Mint16unsigned => Eunop Ocast16unsigned e
| Mint32 => e
- | Mfloat32 => Cmconstr.singleoffloat e
+ | Mfloat32 => Eunop Osingleoffloat e
| Mfloat64 => e
end.
-Definition make_load (chunk: memory_chunk) (e: expr): expr :=
- Cmconstr.load chunk e.
-
Definition store_arg (chunk: memory_chunk) (e: expr) : expr :=
match e with
- | Eop op (Econs e1 Enil) =>
- match op with
- | Ocast8signed =>
- match chunk with Mint8signed => e1 | _ => e end
- | Ocast8unsigned =>
- match chunk with Mint8unsigned => e1 | _ => e end
- | Ocast16signed =>
- match chunk with Mint16signed => e1 | _ => e end
- | Ocast16unsigned =>
- match chunk with Mint16unsigned => e1 | _ => e end
- | Osingleoffloat =>
- match chunk with Mfloat32 => e1 | _ => e end
- | _ => e
- end
+ | Eunop Ocast8signed e1 =>
+ match chunk with Mint8signed => e1 | _ => e end
+ | Eunop Ocast8unsigned e1 =>
+ match chunk with Mint8unsigned => e1 | _ => e end
+ | Eunop Ocast16signed e1 =>
+ match chunk with Mint16signed => e1 | _ => e end
+ | Eunop Ocast16unsigned e1 =>
+ match chunk with Mint16unsigned => e1 | _ => e end
+ | Eunop Osingleoffloat e1 =>
+ match chunk with Mfloat32 => e1 | _ => e end
| _ => e
end.
Definition make_store (chunk: memory_chunk) (e1 e2: expr): stmt :=
- Sexpr(Cmconstr.store chunk e1 (store_arg chunk e2)).
+ Sexpr (Estore chunk e1 (store_arg chunk e2)).
Definition make_stackaddr (ofs: Z): expr :=
- Eop (Oaddrstack (Int.repr ofs)) Enil.
+ Econst (Oaddrstack (Int.repr ofs)).
Definition make_globaladdr (id: ident): expr :=
- Eop (Oaddrsymbol id Int.zero) Enil.
+ Econst (Oaddrsymbol id Int.zero).
(** Compile-time information attached to each Csharpminor
variable: global variables, local variables, function parameters.
@@ -156,134 +107,127 @@ Definition compilenv := PMap.t var_info.
(** Generation of Cminor code corresponding to accesses to Csharpminor
local variables: reads, assignments, and taking the address of. *)
-Definition var_get (cenv: compilenv) (id: ident): option expr :=
+Definition var_get (cenv: compilenv) (id: ident): res expr :=
match PMap.get id cenv with
| Var_local chunk =>
- Some(Evar id)
+ OK(Evar id)
| Var_stack_scalar chunk ofs =>
- Some(make_load chunk (make_stackaddr ofs))
+ OK(Eload chunk (make_stackaddr ofs))
| Var_global_scalar chunk =>
- Some(make_load chunk (make_globaladdr id))
+ OK(Eload chunk (make_globaladdr id))
| _ =>
- None
+ Error(msg "Cminorgen.var_get")
end.
-Definition var_set (cenv: compilenv) (id: ident) (rhs: expr): option stmt :=
+Definition var_set (cenv: compilenv) (id: ident) (rhs: expr): res stmt :=
match PMap.get id cenv with
| Var_local chunk =>
- Some(Sassign id (make_cast chunk rhs))
+ OK(Sassign id (make_cast chunk rhs))
| Var_stack_scalar chunk ofs =>
- Some(make_store chunk (make_stackaddr ofs) rhs)
+ OK(make_store chunk (make_stackaddr ofs) rhs)
| Var_global_scalar chunk =>
- Some(make_store chunk (make_globaladdr id) rhs)
+ OK(make_store chunk (make_globaladdr id) rhs)
| _ =>
- None
+ Error(msg "Cminorgen.var_set")
end.
-Definition var_addr (cenv: compilenv) (id: ident): option expr :=
+Definition var_addr (cenv: compilenv) (id: ident): res expr :=
match PMap.get id cenv with
- | Var_local chunk => None
- | Var_stack_scalar chunk ofs => Some (make_stackaddr ofs)
- | Var_stack_array ofs => Some (make_stackaddr ofs)
- | _ => Some (make_globaladdr id)
- end.
-
-(** The translation from Csharpminor to Cminor can fail, which we
- encode by returning option types ([None] denotes error).
- Propagation of errors is done in monadic style, using the following
- [bind] monadic composition operator, and a [do] notation inspired
- by Haskell's. *)
-
-Definition bind (A B: Set) (a: option A) (b: A -> option B): option B :=
- match a with
- | None => None
- | Some x => b x
+ | Var_local chunk => Error(msg "Cminorgen.var_addr")
+ | Var_stack_scalar chunk ofs => OK (make_stackaddr ofs)
+ | Var_stack_array ofs => OK (make_stackaddr ofs)
+ | _ => OK (make_globaladdr id)
end.
-Notation "'do' X <- A ; B" := (bind _ _ A (fun X => B))
- (at level 200, X ident, A at level 100, B at level 200).
-
(** Translation of expressions. All the hard work is done by the
[make_*] and [var_*] functions defined above. *)
Fixpoint transl_expr (cenv: compilenv) (e: Csharpminor.expr)
- {struct e}: option expr :=
+ {struct e}: res expr :=
match e with
| Csharpminor.Evar id => var_get cenv id
| Csharpminor.Eaddrof id => var_addr cenv id
- | Csharpminor.Eop op el =>
- do tel <- transl_exprlist cenv el; make_op op tel
+ | Csharpminor.Econst cst =>
+ OK (Econst (transl_constant cst))
+ | Csharpminor.Eunop op e1 =>
+ do te1 <- transl_expr cenv e1;
+ OK (Eunop op te1)
+ | Csharpminor.Ebinop op e1 e2 =>
+ do te1 <- transl_expr cenv e1;
+ do te2 <- transl_expr cenv e2;
+ OK (Ebinop op te1 te2)
| Csharpminor.Eload chunk e =>
- do te <- transl_expr cenv e; Some (make_load chunk te)
+ do te <- transl_expr cenv e;
+ OK (Eload chunk te)
| Csharpminor.Ecall sig e el =>
do te <- transl_expr cenv e;
do tel <- transl_exprlist cenv el;
- Some (Ecall sig te tel)
+ OK (Ecall sig te tel)
| Csharpminor.Econdition e1 e2 e3 =>
do te1 <- transl_expr cenv e1;
do te2 <- transl_expr cenv e2;
do te3 <- transl_expr cenv e3;
- Some (Cmconstr.conditionalexpr te1 te2 te3)
+ OK (Econdition te1 te2 te3)
| Csharpminor.Elet e1 e2 =>
do te1 <- transl_expr cenv e1;
do te2 <- transl_expr cenv e2;
- Some (Elet te1 te2)
+ OK (Elet te1 te2)
| Csharpminor.Eletvar n =>
- Some (Eletvar n)
+ OK (Eletvar n)
| Csharpminor.Ealloc e =>
do te <- transl_expr cenv e;
- Some (Ealloc te)
+ OK (Ealloc te)
end
with transl_exprlist (cenv: compilenv) (el: Csharpminor.exprlist)
- {struct el}: option exprlist :=
+ {struct el}: res exprlist :=
match el with
| Csharpminor.Enil =>
- Some Enil
+ OK Enil
| Csharpminor.Econs e1 e2 =>
do te1 <- transl_expr cenv e1;
do te2 <- transl_exprlist cenv e2;
- Some (Econs te1 te2)
+ OK (Econs te1 te2)
end.
(** Translation of statements. Entirely straightforward. *)
Fixpoint transl_stmt (cenv: compilenv) (s: Csharpminor.stmt)
- {struct s}: option stmt :=
+ {struct s}: res stmt :=
match s with
| Csharpminor.Sskip =>
- Some Sskip
+ OK Sskip
| Csharpminor.Sexpr e =>
- do te <- transl_expr cenv e; Some(Sexpr te)
+ do te <- transl_expr cenv e; OK(Sexpr te)
| Csharpminor.Sassign id e =>
do te <- transl_expr cenv e; var_set cenv id te
| Csharpminor.Sstore chunk e1 e2 =>
do te1 <- transl_expr cenv e1;
do te2 <- transl_expr cenv e2;
- Some (make_store chunk te1 te2)
+ OK (make_store chunk te1 te2)
| Csharpminor.Sseq s1 s2 =>
do ts1 <- transl_stmt cenv s1;
do ts2 <- transl_stmt cenv s2;
- Some (Sseq ts1 ts2)
+ OK (Sseq ts1 ts2)
| Csharpminor.Sifthenelse e s1 s2 =>
do te <- transl_expr cenv e;
do ts1 <- transl_stmt cenv s1;
do ts2 <- transl_stmt cenv s2;
- Some (Cmconstr.ifthenelse te ts1 ts2)
+ OK (Sifthenelse te ts1 ts2)
| Csharpminor.Sloop s =>
do ts <- transl_stmt cenv s;
- Some (Sloop ts)
+ OK (Sloop ts)
| Csharpminor.Sblock s =>
do ts <- transl_stmt cenv s;
- Some (Sblock ts)
+ OK (Sblock ts)
| Csharpminor.Sexit n =>
- Some (Sexit n)
+ OK (Sexit n)
| Csharpminor.Sswitch e cases default =>
- do te <- transl_expr cenv e; Some(Sswitch te cases default)
+ do te <- transl_expr cenv e; OK(Sswitch te cases default)
| Csharpminor.Sreturn None =>
- Some (Sreturn None)
+ OK (Sreturn None)
| Csharpminor.Sreturn (Some e) =>
- do te <- transl_expr cenv e; Some (Sreturn (Some te))
+ do te <- transl_expr cenv e; OK (Sreturn (Some te))
end.
(** Computation of the set of variables whose address is taken in
@@ -295,7 +239,10 @@ Fixpoint addr_taken_expr (e: Csharpminor.expr): Identset.t :=
match e with
| Csharpminor.Evar id => Identset.empty
| Csharpminor.Eaddrof id => Identset.add id Identset.empty
- | Csharpminor.Eop op el => addr_taken_exprlist el
+ | Csharpminor.Econst cst => Identset.empty
+ | Csharpminor.Eunop op e1 => addr_taken_expr e1
+ | Csharpminor.Ebinop op e1 e2 =>
+ Identset.union (addr_taken_expr e1) (addr_taken_expr e2)
| Csharpminor.Eload chunk e => addr_taken_expr e
| Csharpminor.Ecall sig e el =>
Identset.union (addr_taken_expr e) (addr_taken_exprlist el)
@@ -416,23 +363,23 @@ Fixpoint store_parameters
overflow machine arithmetic and lead to incorrect code. *)
Definition transl_function
- (gce: compilenv) (f: Csharpminor.function): option function :=
+ (gce: compilenv) (f: Csharpminor.function): res function :=
let (cenv, stacksize) := build_compilenv gce f in
if zle stacksize Int.max_signed then
do tbody <- transl_stmt cenv f.(Csharpminor.fn_body);
- Some (mkfunction
+ OK (mkfunction
(Csharpminor.fn_sig f)
(Csharpminor.fn_params_names f)
(Csharpminor.fn_vars_names f)
stacksize
(Sseq (store_parameters cenv f.(Csharpminor.fn_params)) tbody))
- else None.
+ else Error(msg "Cminorgen: too many local variables, stack size exceeded").
-Definition transl_fundef (gce: compilenv) (f: Csharpminor.fundef): option fundef :=
+Definition transl_fundef (gce: compilenv) (f: Csharpminor.fundef): res fundef :=
transf_partial_fundef (transl_function gce) f.
-Definition transl_globvar (vk: var_kind) := Some tt.
+Definition transl_globvar (vk: var_kind) := OK tt.
-Definition transl_program (p: Csharpminor.program) : option program :=
+Definition transl_program (p: Csharpminor.program) : res program :=
let gce := build_global_compilenv p in
transform_partial_program2 (transl_fundef gce) transl_globvar p.
diff --git a/cfrontend/Cminorgenproof.v b/cfrontend/Cminorgenproof.v
index ad31ff195c4768e8ba0b3e530a49359a350664dd..5bcb88016883818f70ce6333ab1aaf31bf6d58de 100644
--- a/cfrontend/Cminorgenproof.v
+++ b/cfrontend/Cminorgenproof.v
@@ -2,6 +2,7 @@
Require Import FSets.
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import AST.
Require Import Integers.
@@ -11,68 +12,49 @@ Require Import Mem.
Require Import Events.
Require Import Globalenvs.
Require Import Csharpminor.
-Require Import Op.
Require Import Cminor.
-Require Cmconstr.
Require Import Cminorgen.
-Require Import Cmconstrproof.
+
+Open Local Scope error_monad_scope.
Section TRANSLATION.
Variable prog: Csharpminor.program.
Variable tprog: program.
-Hypothesis TRANSL: transl_program prog = Some tprog.
+Hypothesis TRANSL: transl_program prog = OK tprog.
Let ge : Csharpminor.genv := Genv.globalenv prog.
Let tge: genv := Genv.globalenv tprog.
Let gce : compilenv := build_global_compilenv prog.
Lemma symbols_preserved:
forall (s: ident), Genv.find_symbol tge s = Genv.find_symbol ge s.
-Proof.
- intro. unfold ge, tge.
- apply Genv.find_symbol_transf_partial2 with (transl_fundef gce) transl_globvar.
- exact TRANSL.
-Qed.
+Proof (Genv.find_symbol_transf_partial2 (transl_fundef gce) transl_globvar _ TRANSL).
Lemma function_ptr_translated:
forall (b: block) (f: Csharpminor.fundef),
Genv.find_funct_ptr ge b = Some f ->
exists tf,
- Genv.find_funct_ptr tge b = Some tf /\ transl_fundef gce f = Some tf.
-Proof.
- intros.
- generalize
- (Genv.find_funct_ptr_transf_partial2 (transl_fundef gce) transl_globvar TRANSL H).
- case (transl_fundef gce f).
- intros tf [A B]. exists tf. tauto.
- intros [A B]. elim B. reflexivity.
-Qed.
+ Genv.find_funct_ptr tge b = Some tf /\ transl_fundef gce f = OK tf.
+Proof (Genv.find_funct_ptr_transf_partial2 (transl_fundef gce) transl_globvar TRANSL).
+
Lemma functions_translated:
forall (v: val) (f: Csharpminor.fundef),
Genv.find_funct ge v = Some f ->
exists tf,
- Genv.find_funct tge v = Some tf /\ transl_fundef gce f = Some tf.
-Proof.
- intros.
- generalize
- (Genv.find_funct_transf_partial2 (transl_fundef gce) transl_globvar TRANSL H).
- case (transl_fundef gce f).
- intros tf [A B]. exists tf. tauto.
- intros [A B]. elim B. reflexivity.
-Qed.
+ Genv.find_funct tge v = Some tf /\ transl_fundef gce f = OK tf.
+Proof (Genv.find_funct_transf_partial2 (transl_fundef gce) transl_globvar TRANSL).
Lemma sig_preserved:
forall f tf,
- transl_fundef gce f = Some tf ->
+ transl_fundef gce f = OK tf ->
Cminor.funsig tf = Csharpminor.funsig f.
Proof.
intros until tf; destruct f; simpl.
unfold transl_function. destruct (build_compilenv gce f).
- case (zle z Int.max_signed); try congruence.
- intro. case (transl_stmt c (Csharpminor.fn_body f)); simpl; try congruence.
- intros. inversion H. reflexivity.
- intro. inversion H; reflexivity.
+ case (zle z Int.max_signed); simpl; try congruence.
+ intros. monadInv H. monadInv EQ. reflexivity.
+ intro. inv H. reflexivity.
Qed.
Definition global_compilenv_match (ce: compilenv) (gv: gvarenv) : Prop :=
@@ -510,15 +492,12 @@ Lemma load_from_alloc_is_undef:
alloc m1 0 (size_chunk chunk) = (m2, b) ->
load chunk m2 b 0 = Some Vundef.
Proof.
- intros.
- assert (valid_block m2 b). eapply valid_new_block; eauto.
- assert (low_bound m2 b <= 0).
- generalize (low_bound_alloc _ _ b _ _ _ H). rewrite zeq_true. omega.
- assert (0 + size_chunk chunk <= high_bound m2 b).
- generalize (high_bound_alloc _ _ b _ _ _ H). rewrite zeq_true. omega.
- elim (load_in_bounds _ _ _ _ H0 H1 H2). intros v LOAD.
- assert (v = Vundef). eapply load_alloc_same; eauto.
- congruence.
+ intros.
+ assert (exists v, load chunk m2 b 0 = Some v).
+ apply valid_access_load.
+ eapply valid_access_alloc_same; eauto; omega.
+ destruct H0 as [v LOAD]. rewrite LOAD. decEq.
+ eapply load_alloc_same; eauto.
Qed.
Lemma match_env_alloc_same:
@@ -577,14 +556,20 @@ Proof.
contradiction.
(* other vars *)
generalize (me_vars0 id0); intros.
- inversion H6; econstructor; eauto.
- unfold e2; rewrite PTree.gso; auto.
- unfold f2, extend_inject, eq_block; rewrite zeq_false; auto.
- generalize (me_bounded0 _ _ _ H8). unfold block in *; omega.
- unfold e2; rewrite PTree.gso; eauto.
- unfold e2; rewrite PTree.gso; eauto.
- unfold e2; rewrite PTree.gso; eauto.
- unfold e2; rewrite PTree.gso; eauto.
+ inversion H6.
+ eapply match_var_local with (v := v); eauto.
+ unfold e2; rewrite PTree.gso; eauto.
+ eapply load_alloc_other; eauto.
+ unfold f2, extend_inject, eq_block; rewrite zeq_false; auto.
+ generalize (me_bounded0 _ _ _ H8). unfold block in *; omega.
+ econstructor; eauto.
+ unfold e2; rewrite PTree.gso; eauto.
+ econstructor; eauto.
+ unfold e2; rewrite PTree.gso; eauto.
+ econstructor; eauto.
+ unfold e2; rewrite PTree.gso; eauto.
+ econstructor; eauto.
+ unfold e2; rewrite PTree.gso; eauto.
(* lo <= hi *)
unfold block in *; omega.
(* me_bounded *)
@@ -629,9 +614,15 @@ Proof.
inversion H2. constructor; auto.
(* me_vars *)
intros. generalize (me_vars0 id); intro.
- inversion H5; econstructor; eauto.
- unfold f2, extend_inject, eq_block. rewrite zeq_false. auto.
- generalize (me_bounded0 _ _ _ H7). unfold block in *; omega.
+ inversion H5.
+ eapply match_var_local with (v := v); eauto.
+ eapply load_alloc_other; eauto.
+ unfold f2, extend_inject, eq_block. rewrite zeq_false. auto.
+ generalize (me_bounded0 _ _ _ H7). unfold block in *; omega.
+ econstructor; eauto.
+ econstructor; eauto.
+ econstructor; eauto.
+ econstructor; eauto.
(* me_bounded *)
intros until delta. unfold f2, extend_inject, eq_block.
case (zeq b0 b); intros. rewrite H5 in H0. omegaContradiction.
@@ -726,9 +717,10 @@ Proof.
(* me_vars *)
intros. generalize (me_vars0 id); intro. inversion H5.
(* var_local *)
- econstructor; eauto.
+ eapply match_var_local with (v := v); eauto.
+ eapply load_alloc_other; eauto.
generalize (me_bounded0 _ _ _ H7). intro.
- unfold f2, extend_inject. case (eq_block b0 b); intro.
+ unfold f2, extend_inject. case (zeq b0 b); intro.
subst b0. rewrite BEQ in H12. omegaContradiction.
auto.
(* var_stack_scalar *)
@@ -740,12 +732,12 @@ Proof.
(* var_global_array *)
econstructor; eauto.
(* me_bounded *)
- intros until delta. unfold f2, extend_inject. case (eq_block b0 b); intro.
+ intros until delta. unfold f2, extend_inject. case (zeq b0 b); intro.
intro. injection H5; clear H5; intros.
rewrite H6 in TBEQ. rewrite TBEQ in H3. omegaContradiction.
eauto.
(* me_inj *)
- intros until delta. unfold f2, extend_inject. case (eq_block b0 b); intros.
+ intros until delta. unfold f2, extend_inject. case (zeq b0 b); intros.
injection H5; clear H5; intros; subst b0 tb0 delta.
rewrite BEQ in H6. omegaContradiction.
eauto.
@@ -804,16 +796,7 @@ Qed.
(** * Correctness of Cminor construction functions *)
-Hint Resolve eval_negint eval_negfloat eval_absfloat eval_intoffloat
- eval_floatofint eval_floatofintu eval_notint eval_notbool
- eval_cast8signed eval_cast8unsigned eval_cast16signed
- eval_cast16unsigned eval_singleoffloat eval_add eval_add_ptr
- eval_add_ptr_2 eval_sub eval_sub_ptr_int eval_sub_ptr_ptr
- eval_mul eval_divs eval_mods eval_divu eval_modu
- eval_and eval_or eval_xor eval_shl eval_shr eval_shru
- eval_addf eval_subf eval_mulf eval_divf
- eval_cmp eval_cmp_null_r eval_cmp_null_l eval_cmp_ptr
- eval_cmpu eval_cmpf: evalexpr.
+Hint Resolve eval_Econst eval_Eunop eval_Ebinop eval_Eload: evalexpr.
Remark val_inject_val_of_bool:
forall f b, val_inject f (Val.of_bool b) (Val.of_bool b).
@@ -821,151 +804,146 @@ Proof.
intros; destruct b; unfold Val.of_bool, Vtrue, Vfalse; constructor.
Qed.
+Remark val_inject_bool_of_val:
+ forall f v b tv,
+ val_inject f v tv -> Val.bool_of_val v b -> Val.bool_of_val tv b.
+Proof.
+ intros. inv H; inv H0; constructor; auto.
+Qed.
+
+Remark val_inject_eval_compare_null:
+ forall f c i v,
+ eval_compare_null c i = Some v ->
+ val_inject f v v.
+Proof.
+ unfold eval_compare_null; intros.
+ destruct (Int.eq i Int.zero).
+ destruct c; inv H; unfold Vfalse, Vtrue; constructor.
+ discriminate.
+Qed.
+
Ltac TrivialOp :=
match goal with
- | [ |- exists x, _ /\ val_inject _ (Vint ?x) _ ] =>
+ | [ |- exists y, _ /\ val_inject _ (Vint ?x) _ ] =>
exists (Vint x); split;
[eauto with evalexpr | constructor]
- | [ |- exists x, _ /\ val_inject _ (Vfloat ?x) _ ] =>
+ | [ |- exists y, _ /\ val_inject _ (Vfloat ?x) _ ] =>
exists (Vfloat x); split;
[eauto with evalexpr | constructor]
- | [ |- exists x, _ /\ val_inject _ (Val.of_bool ?x) _ ] =>
+ | [ |- exists y, _ /\ val_inject _ (Val.of_bool ?x) _ ] =>
exists (Val.of_bool x); split;
[eauto with evalexpr | apply val_inject_val_of_bool]
+ | [ |- exists y, Some ?x = Some y /\ val_inject _ _ _ ] =>
+ exists x; split; [auto | econstructor; eauto]
| _ => idtac
end.
-Remark eval_compare_null_inv:
- forall c i v,
- Csharpminor.eval_compare_null c i = Some v ->
- i = Int.zero /\ (c = Ceq /\ v = Vfalse \/ c = Cne /\ v = Vtrue).
+(** Correctness of [transl_constant]. *)
+
+Lemma transl_constant_correct:
+ forall f sp cst v,
+ Csharpminor.eval_constant cst = Some v ->
+ exists tv,
+ eval_constant tge sp (transl_constant cst) = Some tv
+ /\ val_inject f v tv.
Proof.
- intros until v. unfold Csharpminor.eval_compare_null.
- predSpec Int.eq Int.eq_spec i Int.zero.
- case c; intro EQ; simplify_eq EQ; intro; subst v; tauto.
- congruence.
+ destruct cst; simpl; intros; inv H; TrivialOp.
Qed.
-(** Correctness of [make_op]. The generated Cminor code evaluates
- to a value that matches the result value of the Csharpminor operation,
- provided arguments match pairwise ([val_list_inject f] hypothesis). *)
+(** Compatibility of [eval_unop] with respect to [val_inject]. *)
-Lemma make_op_correct:
- forall al a op vl m2 v sp le te tm1 t tm2 tvl f,
- make_op op al = Some a ->
- Csharpminor.eval_operation op vl m2 = Some v ->
- eval_exprlist tge (Vptr sp Int.zero) le te tm1 al t tm2 tvl ->
- val_list_inject f vl tvl ->
- mem_inject f m2 tm2 ->
+Lemma eval_unop_compat:
+ forall f op v1 tv1 v,
+ eval_unop op v1 = Some v ->
+ val_inject f v1 tv1 ->
exists tv,
- eval_expr tge (Vptr sp Int.zero) le te tm1 a t tm2 tv
+ eval_unop op tv1 = Some tv
/\ val_inject f v tv.
Proof.
- intros.
- destruct al as [ | a1 al];
- [idtac | destruct al as [ | a2 al];
- [idtac | destruct al as [ | a3 al]]];
- simpl in H; try discriminate.
- (* Constant operators *)
- inversion H1. subst sp0 le0 e m tm1 tvl.
- inversion H2. subst vl.
- destruct op; simplify_eq H; intro; subst a;
- simpl in H0; injection H0; intro; subst v.
- (* intconst *)
- TrivialOp. econstructor. constructor. reflexivity.
- (* floatconst *)
- TrivialOp. econstructor. constructor. reflexivity.
- (* Unary operators *)
- inversion H1; clear H1; subst.
- inversion H11; clear H11; subst.
- rewrite E0_right.
- inversion H2; clear H2; subst. inversion H8; clear H8; subst.
- destruct op; simplify_eq H; intro; subst a;
- simpl in H0; destruct v1; simplify_eq H0; intro; subst v;
- inversion H7; subst v0;
- TrivialOp.
- change (Vint (Int.cast8unsigned i)) with (Val.cast8unsigned (Vint i)). eauto with evalexpr.
- change (Vint (Int.cast8signed i)) with (Val.cast8signed (Vint i)). eauto with evalexpr.
- change (Vint (Int.cast16unsigned i)) with (Val.cast16unsigned (Vint i)). eauto with evalexpr.
- change (Vint (Int.cast16signed i)) with (Val.cast16signed (Vint i)). eauto with evalexpr.
- replace (Int.eq i Int.zero) with (negb (negb (Int.eq i Int.zero))).
- eapply eval_notbool. eauto.
- generalize (Int.eq_spec i Int.zero). destruct (Int.eq i Int.zero); intro; simpl.
- rewrite H1; constructor. constructor; auto.
- apply negb_elim.
- unfold Vfalse; TrivialOp. change (Vint Int.zero) with (Val.of_bool (negb true)).
- eapply eval_notbool. eauto. constructor.
- change (Vfloat (Float.singleoffloat f0)) with (Val.singleoffloat (Vfloat f0)). eauto with evalexpr.
- (* Binary operations *)
- inversion H1; clear H1; subst. inversion H11; clear H11; subst.
- inversion H12; clear H12; subst. rewrite E0_right.
- inversion H2; clear H2; subst. inversion H9; clear H9; subst.
- inversion H10; clear H10; subst.
- destruct op; simplify_eq H; intro; subst a;
- simpl in H0; destruct v2; destruct v3; simplify_eq H0; intro; try subst v;
- inversion H7; inversion H8; subst v0; subst v1;
- TrivialOp.
- (* add int ptr *)
- exists (Vptr b2 (Int.add ofs2 i)); split.
- eauto with evalexpr. apply val_inject_ptr with x. auto.
- subst ofs2. repeat rewrite Int.add_assoc. decEq. apply Int.add_commut.
- (* add ptr int *)
- exists (Vptr b2 (Int.add ofs2 i0)); split.
- eauto with evalexpr. apply val_inject_ptr with x. auto.
- subst ofs2. repeat rewrite Int.add_assoc. decEq. apply Int.add_commut.
- (* sub ptr int *)
- exists (Vptr b2 (Int.sub ofs2 i0)); split.
- eauto with evalexpr. apply val_inject_ptr with x. auto.
- subst ofs2. apply Int.sub_add_l.
- (* sub ptr ptr *)
- destruct (eq_block b b0); simplify_eq H0; intro; subst v; subst b0.
- assert (b4 = b2). congruence. subst b4.
- exists (Vint (Int.sub ofs3 ofs2)); split.
- eauto with evalexpr.
- subst ofs2 ofs3. replace x0 with x. rewrite Int.sub_shifted. constructor.
- congruence.
- (* divs *)
- generalize (Int.eq_spec i0 Int.zero); destruct (Int.eq i0 Int.zero); intro;
- simplify_eq H0; intro; subst v. TrivialOp.
- (* divu *)
- generalize (Int.eq_spec i0 Int.zero); destruct (Int.eq i0 Int.zero); intro;
- simplify_eq H0; intro; subst v. TrivialOp.
- (* mods *)
- generalize (Int.eq_spec i0 Int.zero); destruct (Int.eq i0 Int.zero); intro;
- simplify_eq H0; intro; subst v. TrivialOp.
- (* modu *)
- generalize (Int.eq_spec i0 Int.zero); destruct (Int.eq i0 Int.zero); intro;
- simplify_eq H0; intro; subst v. TrivialOp.
- (* shl *)
- caseEq (Int.ltu i0 (Int.repr 32)); intro EQ; rewrite EQ in H0;
- simplify_eq H0; intro; subst v. TrivialOp.
- (* shr *)
- caseEq (Int.ltu i0 (Int.repr 32)); intro EQ; rewrite EQ in H0;
- simplify_eq H0; intro; subst v. TrivialOp.
- (* shru *)
- caseEq (Int.ltu i0 (Int.repr 32)); intro EQ; rewrite EQ in H0;
- simplify_eq H0; intro; subst v. TrivialOp.
- (* cmp int ptr *)
- elim (eval_compare_null_inv _ _ _ H0); intros; subst i1 i.
- exists v; split. eauto with evalexpr.
- elim H12; intros [A B]; subst v; unfold Vtrue, Vfalse; constructor.
- (* cmp ptr int *)
- elim (eval_compare_null_inv _ _ _ H0); intros; subst i1 i0.
- exists v; split. eauto with evalexpr.
- elim H12; intros [A B]; subst v; unfold Vtrue, Vfalse; constructor.
+ destruct op; simpl; intros.
+ inv H; inv H0; simpl; TrivialOp.
+ inv H; inv H0; simpl; TrivialOp.
+ inv H; inv H0; simpl; TrivialOp.
+ inv H; inv H0; simpl; TrivialOp.
+ inv H0; inv H. TrivialOp.
+ inv H0; inv H. TrivialOp. unfold Vfalse; TrivialOp.
+ inv H0; inv H; TrivialOp.
+ inv H0; inv H; TrivialOp.
+ inv H0; inv H; TrivialOp.
+ inv H; inv H0; simpl; TrivialOp.
+ inv H0; inv H; TrivialOp.
+ inv H0; inv H; TrivialOp.
+ inv H0; inv H; TrivialOp.
+Qed.
+
+(** Compatibility of [eval_binop] with respect to [val_inject]. *)
+
+Lemma eval_binop_compat:
+ forall f op v1 tv1 v2 tv2 v m tm,
+ eval_binop op v1 v2 m = Some v ->
+ val_inject f v1 tv1 ->
+ val_inject f v2 tv2 ->
+ mem_inject f m tm ->
+ exists tv,
+ eval_binop op tv1 tv2 tm = Some tv
+ /\ val_inject f v tv.
+Proof.
+ destruct op; simpl; intros.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ repeat rewrite Int.add_assoc. decEq. apply Int.add_commut.
+ repeat rewrite Int.add_assoc. decEq. apply Int.add_commut.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ apply Int.sub_add_l.
+ destruct (eq_block b1 b0); inv H4.
+ assert (b3 = b2) by congruence. subst b3.
+ unfold eq_block; rewrite zeq_true. TrivialOp.
+ replace x0 with x by congruence. decEq. decEq.
+ apply Int.sub_shifted.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ destruct (Int.eq i0 Int.zero); inv H1. TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ destruct (Int.eq i0 Int.zero); inv H1. TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ destruct (Int.eq i0 Int.zero); inv H1. TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ destruct (Int.eq i0 Int.zero); inv H1. TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ destruct (Int.ltu i0 (Int.repr 32)); inv H1. TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ destruct (Int.ltu i0 (Int.repr 32)); inv H1. TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ destruct (Int.ltu i0 (Int.repr 32)); inv H1. TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ exists v; split; auto. eapply val_inject_eval_compare_null; eauto.
+ exists v; split; auto. eapply val_inject_eval_compare_null; eauto.
(* cmp ptr ptr *)
- caseEq (valid_pointer m2 b (Int.signed i) && valid_pointer m2 b0 (Int.signed i0));
- intro EQ; rewrite EQ in H0; try discriminate.
- destruct (eq_block b b0); simplify_eq H0; intro; subst v b0.
- assert (b4 = b2); [congruence|subst b4].
- assert (x0 = x); [congruence|subst x0].
+ caseEq (valid_pointer m b1 (Int.signed ofs1) && valid_pointer m b0 (Int.signed ofs0));
+ intro EQ; rewrite EQ in H4; try discriminate.
+ destruct (eq_block b1 b0); inv H4.
+ assert (b3 = b2) by congruence. subst b3.
+ assert (x0 = x) by congruence. subst x0.
elim (andb_prop _ _ EQ); intros.
- exists (Val.of_bool (Int.cmp c ofs3 ofs2)); split.
- eauto with evalexpr.
- subst ofs2 ofs3. rewrite Int.translate_cmp.
- apply val_inject_val_of_bool.
+ exists (Val.of_bool (Int.cmp c ofs1 ofs0)); split.
+ exploit (Mem.valid_pointer_inject f m tm b0 ofs0); eauto.
+ intro VP; rewrite VP; clear VP.
+ exploit (Mem.valid_pointer_inject f m tm b0 ofs1); eauto.
+ intro VP; rewrite VP; clear VP.
+ unfold eq_block; rewrite zeq_true; simpl.
+ decEq. decEq. rewrite Int.translate_cmp. auto.
eapply valid_pointer_inject_no_overflow; eauto.
eapply valid_pointer_inject_no_overflow; eauto.
+ apply val_inject_val_of_bool.
+ (* *)
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
+ inv H0; try discriminate; inv H1; inv H; TrivialOp.
Qed.
(** Correctness of [make_cast]. Note that the resulting Cminor value is
@@ -980,35 +958,28 @@ Lemma make_cast_correct:
te tm1 (make_cast chunk a) t tm2 tv'
/\ val_inject f (Val.load_result chunk v) tv'.
Proof.
- intros. destruct chunk.
+ intros. destruct chunk; simpl make_cast.
exists (Val.cast8signed tv).
- split. apply eval_cast8signed; auto.
- inversion H0; simpl; constructor.
+ split. eauto with evalexpr. inversion H0; simpl; constructor.
exists (Val.cast8unsigned tv).
- split. apply eval_cast8unsigned; auto.
- inversion H0; simpl; constructor.
+ split. eauto with evalexpr. inversion H0; simpl; constructor.
exists (Val.cast16signed tv).
- split. apply eval_cast16signed; auto.
- inversion H0; simpl; constructor.
+ split. eauto with evalexpr. inversion H0; simpl; constructor.
exists (Val.cast16unsigned tv).
- split. apply eval_cast16unsigned; auto.
- inversion H0; simpl; constructor.
+ split. eauto with evalexpr. inversion H0; simpl; constructor.
- exists tv.
- split. simpl; auto.
- inversion H0; simpl; econstructor; eauto.
+ exists tv.
+ split. auto. inversion H0; simpl; econstructor; eauto.
exists (Val.singleoffloat tv).
- split. apply eval_singleoffloat; auto.
- inversion H0; simpl; constructor.
+ split. eauto with evalexpr. inversion H0; simpl; constructor.
- exists tv.
- split. simpl; auto.
- inversion H0; simpl; constructor.
+ exists tv.
+ split. auto. inversion H0; simpl; econstructor; eauto.
Qed.
Lemma make_stackaddr_correct:
@@ -1018,7 +989,7 @@ Lemma make_stackaddr_correct:
E0 tm (Vptr sp (Int.repr ofs)).
Proof.
intros; unfold make_stackaddr.
- eapply eval_Eop. econstructor. simpl. decEq. decEq.
+ econstructor. simpl. decEq. decEq.
rewrite Int.add_commut. apply Int.add_zero.
Qed.
@@ -1030,22 +1001,10 @@ Lemma make_globaladdr_correct:
E0 tm (Vptr b Int.zero).
Proof.
intros; unfold make_globaladdr.
- eapply eval_Eop. econstructor. simpl. rewrite H. auto.
+ econstructor. simpl. rewrite H. auto.
Qed.
-(** Correctness of [make_load] and [make_store]. *)
-
-Lemma make_load_correct:
- forall sp le te tm1 a t tm2 va chunk v,
- eval_expr tge (Vptr sp Int.zero) le te tm1 a t tm2 va ->
- Mem.loadv chunk tm2 va = Some v ->
- eval_expr tge (Vptr sp Int.zero) le
- te tm1 (make_load chunk a)
- t tm2 v.
-Proof.
- intros; unfold make_load.
- eapply eval_load; eauto.
-Qed.
+(** Correctness of [make_store]. *)
Lemma store_arg_content_inject:
forall f sp le te tm1 a t tm2 v va chunk,
@@ -1053,25 +1012,23 @@ Lemma store_arg_content_inject:
val_inject f v va ->
exists vb,
eval_expr tge (Vptr sp Int.zero) le te tm1 (store_arg chunk a) t tm2 vb
- /\ val_content_inject f (mem_chunk chunk) v vb.
+ /\ val_content_inject f chunk v vb.
Proof.
intros.
assert (exists vb,
eval_expr tge (Vptr sp Int.zero) le te tm1 a t tm2 vb
- /\ val_content_inject f (mem_chunk chunk) v vb).
+ /\ val_content_inject f chunk v vb).
exists va; split. assumption. constructor. assumption.
- inversion H; clear H; subst; simpl; trivial.
- inversion H2; clear H2; subst; trivial.
- inversion H4; clear H4; subst; trivial.
- rewrite E0_right. rewrite E0_right in H1.
- destruct op; trivial; destruct chunk; trivial;
- exists v0; (split; [auto|
- simpl in H3; inversion H3; clear H3; subst va;
- destruct v0; simpl in H0; inversion H0; subst; try (constructor; constructor)]).
- apply val_content_inject_8. apply Int.cast8_unsigned_signed.
- apply val_content_inject_8. apply Int.cast8_unsigned_idem.
- apply val_content_inject_16. apply Int.cast16_unsigned_signed.
- apply val_content_inject_16. apply Int.cast16_unsigned_idem.
+ destruct a; simpl store_arg; trivial;
+ destruct u; trivial;
+ destruct chunk; trivial;
+ inv H; simpl in H12; inv H12;
+ econstructor; (split; [eauto|idtac]);
+ destruct v1; simpl in H0; inv H0; try (constructor; constructor).
+ apply val_content_inject_8. auto. apply Int.cast8_unsigned_idem.
+ apply val_content_inject_8; auto. apply Int.cast8_unsigned_signed.
+ apply val_content_inject_16; auto. apply Int.cast16_unsigned_idem.
+ apply val_content_inject_16; auto. apply Int.cast16_unsigned_signed.
apply val_content_inject_32. apply Float.singleoffloat_idem.
Qed.
@@ -1098,13 +1055,11 @@ Proof.
intros [tv [EVAL VCINJ]].
exploit storev_mapped_inject_1; eauto.
intros [tm4 [STORE MEMINJ]].
- exploit eval_store. eexact H. eexact EVAL. eauto.
- intro EVALSTORE.
exists tm4.
- split. apply exec_Sexpr with tv. auto.
+ split. apply exec_Sexpr with tv. eapply eval_Estore; eauto.
split. auto.
unfold storev in STORE; destruct tvaddr; try discriminate.
- exploit store_inv; eauto. simpl. tauto.
+ eapply nextblock_store; eauto.
Qed.
(** Correctness of the variable accessors [var_get], [var_set]
@@ -1112,7 +1067,7 @@ Qed.
Lemma var_get_correct:
forall cenv id a f e te sp lo hi m cs tm b chunk v le,
- var_get cenv id = Some a ->
+ var_get cenv id = OK a ->
match_callstack f (mkframe cenv e te sp lo hi :: cs) m.(nextblock) tm.(nextblock) m ->
mem_inject f m tm ->
eval_var_ref prog e id b chunk ->
@@ -1138,7 +1093,7 @@ Proof.
unfold loadv. eexact H3.
intros [tv [LOAD INJ]].
exists tv; split.
- eapply make_load_correct; eauto. eapply make_stackaddr_correct; eauto.
+ econstructor; eauto. eapply make_stackaddr_correct; eauto.
auto.
(* var_global_scalar *)
inversion H2; [congruence|subst].
@@ -1151,14 +1106,14 @@ Proof.
generalize (loadv_inject _ _ _ _ _ _ _ H1 H12 H13).
intros [tv [LOAD INJ]].
exists tv; split.
- eapply make_load_correct; eauto. eapply make_globaladdr_correct; eauto.
+ econstructor; eauto. eapply make_globaladdr_correct; eauto.
auto.
Qed.
Lemma var_addr_correct:
forall cenv id a f e te sp lo hi m cs tm b le,
match_callstack f (mkframe cenv e te sp lo hi :: cs) m.(nextblock) tm.(nextblock) m ->
- var_addr cenv id = Some a ->
+ var_addr cenv id = OK a ->
eval_var_addr prog e id b ->
exists tv,
eval_expr tge (Vptr sp Int.zero) le te tm a E0 tm tv /\
@@ -1196,7 +1151,7 @@ Qed.
Lemma var_set_correct:
forall cenv id rhs a f e te sp lo hi m2 cs tm2 tm1 tv b chunk v m3 t,
- var_set cenv id rhs = Some a ->
+ var_set cenv id rhs = OK a ->
match_callstack f (mkframe cenv e te sp lo hi :: cs) m2.(nextblock) tm2.(nextblock) m2 ->
eval_expr tge (Vptr sp Int.zero) nil te tm1 rhs t tm2 tv ->
val_inject f v tv ->
@@ -1210,7 +1165,7 @@ Lemma var_set_correct:
Proof.
unfold var_set; intros.
assert (NEXTBLOCK: nextblock m3 = nextblock m2).
- exploit store_inv; eauto. simpl; tauto.
+ eapply nextblock_store; eauto.
inversion H0. subst.
assert (match_var f id e m2 te sp cenv!!id). inversion H19; auto.
inversion H6; subst; rewrite <- H7 in H; inversion H; subst; clear H.
@@ -1337,7 +1292,7 @@ Proof.
unfold f1; rewrite <- H2; eapply match_callstack_alloc_left; eauto.
rewrite <- H1. omega.
intros until delta; unfold f1, extend_inject, eq_block.
- rewrite (high_bound_alloc _ _ b _ _ _ H).
+ rewrite (high_bound_alloc _ _ _ _ _ H b).
case (zeq b b1); intros.
inversion H3. unfold sizeof; rewrite LV. omega.
generalize (BOUND _ _ H3). omega.
@@ -1350,7 +1305,7 @@ Proof.
exploit IHalloc_variables; eauto.
unfold f1; rewrite <- H2; eapply match_callstack_alloc_left; eauto.
intros until delta; unfold f1, extend_inject, eq_block.
- rewrite (high_bound_alloc _ _ b _ _ _ H).
+ rewrite (high_bound_alloc _ _ _ _ _ H b).
case (zeq b b1); intros. discriminate.
eapply BOUND; eauto.
intros [f' [INCR2 [MINJ2 MATCH2]]].
@@ -1373,7 +1328,7 @@ Proof.
unfold f1; rewrite <- H2; eapply match_callstack_alloc_left; eauto.
rewrite <- H1. omega.
intros until delta; unfold f1, extend_inject, eq_block.
- rewrite (high_bound_alloc _ _ b _ _ _ H).
+ rewrite (high_bound_alloc _ _ _ _ _ H b).
case (zeq b b1); intros.
inversion H6. unfold sizeof; rewrite LV. omega.
generalize (BOUND _ _ H6). omega.
@@ -1439,10 +1394,9 @@ Proof.
intros.
assert (SP: sp = nextblock tm). injection H2; auto.
unfold build_compilenv in H.
- eapply match_callstack_alloc_variables_rec with (sz' := sz); eauto.
- eapply valid_new_block; eauto.
- rewrite (low_bound_alloc _ _ sp _ _ _ H2). apply zeq_true.
- rewrite (high_bound_alloc _ _ sp _ _ _ H2). apply zeq_true.
+ eapply match_callstack_alloc_variables_rec with (sz' := sz); eauto with mem.
+ eapply low_bound_alloc_same; eauto.
+ eapply high_bound_alloc_same; eauto.
(* match_callstack *)
constructor. omega. change (valid_block tm' sp). eapply valid_new_block; eauto.
constructor.
@@ -1460,15 +1414,15 @@ Proof.
(* me_inj *)
intros until lv2. unfold Csharpminor.empty_env; rewrite PTree.gempty; congruence.
(* me_inv *)
- intros. exploit mi_mappedblocks; eauto. intros [A B].
+ intros. exploit mi_mappedblocks; eauto. intro A.
elim (fresh_block_alloc _ _ _ _ _ H2 A).
(* me_incr *)
- intros. exploit mi_mappedblocks; eauto. intros [A B].
+ intros. exploit mi_mappedblocks; eauto. intro A.
rewrite SP; auto.
rewrite SP; auto.
eapply alloc_right_inject; eauto.
omega.
- intros. exploit mi_mappedblocks; eauto. intros [A B].
+ intros. exploit mi_mappedblocks; eauto. unfold valid_block; intro.
unfold block in SP; omegaContradiction.
(* defined *)
intros. unfold te. apply set_locals_params_defined.
@@ -1569,7 +1523,7 @@ Proof.
inversion H18.
inversion NOREPET. subst hd tl.
assert (NEXT: nextblock m1 = nextblock m).
- exploit store_inv; eauto. simpl; tauto.
+ eapply nextblock_store; eauto.
generalize (me_vars0 id). intro. inversion H2; subst.
(* cenv!!id = Var_local chunk *)
assert (b0 = b). congruence. subst b0.
@@ -1724,43 +1678,6 @@ Qed.
(** * Semantic preservation for the translation *)
-(** These tactics simplify hypotheses of the form [f ... = Some x]. *)
-
-Ltac monadSimpl1 :=
- match goal with
- | [ |- (bind _ _ ?F ?G = Some ?X) -> _ ] =>
- unfold bind at 1;
- generalize (refl_equal F);
- pattern F at -1 in |- *;
- case F;
- [ (let EQ := fresh "EQ" in
- (intro; intro EQ;
- try monadSimpl1))
- | intros; discriminate ]
- | [ |- (None = Some _) -> _ ] =>
- intro; discriminate
- | [ |- (Some _ = Some _) -> _ ] =>
- let h := fresh "H" in
- (intro h; injection h; intro; clear h)
- end.
-
-Ltac monadSimpl :=
- match goal with
- | [ |- (bind _ _ ?F ?G = Some ?X) -> _ ] => monadSimpl1
- | [ |- (None = Some _) -> _ ] => monadSimpl1
- | [ |- (Some _ = Some _) -> _ ] => monadSimpl1
- | [ |- (?F _ _ _ _ _ _ _ = Some _) -> _ ] => simpl F; monadSimpl1
- | [ |- (?F _ _ _ _ _ _ = Some _) -> _ ] => simpl F; monadSimpl1
- | [ |- (?F _ _ _ _ _ = Some _) -> _ ] => simpl F; monadSimpl1
- | [ |- (?F _ _ _ _ = Some _) -> _ ] => simpl F; monadSimpl1
- | [ |- (?F _ _ _ = Some _) -> _ ] => simpl F; monadSimpl1
- | [ |- (?F _ _ = Some _) -> _ ] => simpl F; monadSimpl1
- | [ |- (?F _ = Some _) -> _ ] => simpl F; monadSimpl1
- end.
-
-Ltac monadInv H :=
- generalize H; monadSimpl.
-
(** The proof of semantic preservation uses simulation diagrams of the
following form:
<<
@@ -1790,7 +1707,7 @@ Ltac monadInv H :=
Definition eval_expr_prop
(le: Csharpminor.letenv) (e: Csharpminor.env) (m1: mem) (a: Csharpminor.expr) (t: trace) (m2: mem) (v: val) : Prop :=
forall cenv ta f1 tle te tm1 sp lo hi cs
- (TR: transl_expr cenv a = Some ta)
+ (TR: transl_expr cenv a = OK ta)
(LINJ: val_list_inject f1 le tle)
(MINJ: mem_inject f1 m1 tm1)
(MATCH: match_callstack f1
@@ -1808,7 +1725,7 @@ Definition eval_expr_prop
Definition eval_exprlist_prop
(le: Csharpminor.letenv) (e: Csharpminor.env) (m1: mem) (al: Csharpminor.exprlist) (t: trace) (m2: mem) (vl: list val) : Prop :=
forall cenv tal f1 tle te tm1 sp lo hi cs
- (TR: transl_exprlist cenv al = Some tal)
+ (TR: transl_exprlist cenv al = OK tal)
(LINJ: val_list_inject f1 le tle)
(MINJ: mem_inject f1 m1 tm1)
(MATCH: match_callstack f1
@@ -1826,7 +1743,7 @@ Definition eval_exprlist_prop
Definition eval_funcall_prop
(m1: mem) (fn: Csharpminor.fundef) (args: list val) (t: trace) (m2: mem) (res: val) : Prop :=
forall tfn f1 tm1 cs targs
- (TR: transl_fundef gce fn = Some tfn)
+ (TR: transl_fundef gce fn = OK tfn)
(MINJ: mem_inject f1 m1 tm1)
(MATCH: match_callstack f1 cs m1.(nextblock) tm1.(nextblock) m1)
(ARGSINJ: val_list_inject f1 args targs),
@@ -1852,7 +1769,7 @@ Inductive outcome_inject (f: meminj) : Csharpminor.outcome -> outcome -> Prop :=
Definition exec_stmt_prop
(e: Csharpminor.env) (m1: mem) (s: Csharpminor.stmt) (t: trace) (m2: mem) (out: Csharpminor.outcome): Prop :=
forall cenv ts f1 te1 tm1 sp lo hi cs
- (TR: transl_stmt cenv s = Some ts)
+ (TR: transl_stmt cenv s = OK ts)
(MINJ: mem_inject f1 m1 tm1)
(MATCH: match_callstack f1
(mkframe cenv e te1 sp lo hi :: cs)
@@ -1897,21 +1814,61 @@ Proof.
exists f1; exists tm1; exists tv. intuition eauto.
Qed.
-Lemma transl_expr_Eop_correct:
- forall (le : Csharpminor.letenv) (e : Csharpminor.env) (m : mem)
- (op : Csharpminor.operation) (al : Csharpminor.exprlist)
- (t: trace) (m1 : mem) (vl : list val) (v : val),
- Csharpminor.eval_exprlist prog le e m al t m1 vl ->
- eval_exprlist_prop le e m al t m1 vl ->
- Csharpminor.eval_operation op vl m1 = Some v ->
- eval_expr_prop le e m (Csharpminor.Eop op al) t m1 v.
-Proof.
- intros; red; intros. monadInv TR; intro EQ0.
+Lemma transl_expr_Econst_correct:
+ forall (le : Csharpminor.letenv) (e : Csharpminor.env) (m : mem)
+ (cst : Csharpminor.constant) (v : val),
+ Csharpminor.eval_constant cst = Some v ->
+ eval_expr_prop le e m (Csharpminor.Econst cst) E0 m v.
+Proof.
+ intros; red; intros; monadInv TR.
+ exploit transl_constant_correct; eauto.
+ intros [tv [EVAL VINJ]].
+ exists f1; exists tm1; exists tv. intuition eauto.
+ constructor; eauto.
+Qed.
+
+Lemma transl_expr_Eunop_correct:
+ forall (le : Csharpminor.letenv) (e : Csharpminor.env) (m : mem)
+ (op : unary_operation) (a : Csharpminor.expr) (t : trace)
+ (m1 : mem) (v1 v : val),
+ Csharpminor.eval_expr prog le e m a t m1 v1 ->
+ eval_expr_prop le e m a t m1 v1 ->
+ Csharpminor.eval_unop op v1 = Some v ->
+ eval_expr_prop le e m (Csharpminor.Eunop op a) t m1 v.
+Proof.
+ intros; red; intros. monadInv TR.
exploit H0; eauto.
intros [f2 [tm2 [tvl [EVAL1 [VINJ1 [MINJ1 [INCR1 MATCH1]]]]]]].
- exploit make_op_correct; eauto.
- intros [tv [EVAL2 VINJ2]].
- exists f2; exists tm2; exists tv. intuition.
+ exploit eval_unop_compat; eauto. intros [tv [EVAL VINJ]].
+ exists f2; exists tm2; exists tv; intuition.
+ econstructor; eauto.
+Qed.
+
+Lemma transl_expr_Ebinop_correct:
+ forall (le : Csharpminor.letenv) (e : Csharpminor.env) (m : mem)
+ (op : binary_operation) (a1 a2 : Csharpminor.expr) (t1 : trace)
+ (m1 : mem) (v1 : val) (t2 : trace) (m2 : mem) (v2 : val)
+ (t : trace) (v : val),
+ Csharpminor.eval_expr prog le e m a1 t1 m1 v1 ->
+ eval_expr_prop le e m a1 t1 m1 v1 ->
+ Csharpminor.eval_expr prog le e m1 a2 t2 m2 v2 ->
+ eval_expr_prop le e m1 a2 t2 m2 v2 ->
+ Csharpminor.eval_binop op v1 v2 m2 = Some v ->
+ t = t1 ** t2 ->
+ eval_expr_prop le e m (Csharpminor.Ebinop op a1 a2) t m2 v.
+Proof.
+ intros; red; intros. monadInv TR.
+ exploit H0; eauto.
+ intros [f2 [tm2 [tvl [EVAL1 [VINJ1 [MINJ1 [INCR1 MATCH1]]]]]]].
+ exploit H2.
+ eauto. eapply val_list_inject_incr; eauto. eauto. eauto.
+ intros [f3 [tm3 [tv2 [EVAL2 [VINJ2 [MINJ2 [INCR2 MATCH2]]]]]]].
+ exploit eval_binop_compat.
+ eauto. eapply val_inject_incr; eauto. eauto. eauto.
+ intros [tv [EVAL VINJ]].
+ exists f3; exists tm3; exists tv; intuition.
+ econstructor; eauto.
+ eapply inject_incr_trans; eauto.
Qed.
Lemma transl_expr_Eload_correct:
@@ -1931,7 +1888,7 @@ Proof.
intros [tv [TLOAD VINJ]].
exists f2; exists tm2; exists tv.
intuition.
- subst ta. eapply make_load_correct; eauto.
+ econstructor; eauto.
Qed.
Lemma transl_expr_Ecall_correct:
@@ -1951,7 +1908,7 @@ Lemma transl_expr_Ecall_correct:
t = t1 ** t2 ** t3 ->
eval_expr_prop le e m (Csharpminor.Ecall sig a bl) t m3 vres.
Proof.
- intros;red;intros. monadInv TR. subst ta.
+ intros;red;intros. monadInv TR.
exploit H0; eauto.
intros [f2 [tm2 [tv1 [EVAL1 [VINJ1 [MINJ1 [INCR1 MATCH1]]]]]]].
exploit H2.
@@ -1960,18 +1917,18 @@ Proof.
assert (tv1 = vf).
elim (Genv.find_funct_inv H3). intros bf VF. rewrite VF in H3.
rewrite Genv.find_funct_find_funct_ptr in H3.
- generalize (Genv.find_funct_ptr_inv H3). intro.
+ generalize (Genv.find_funct_ptr_negative H3). intro.
assert (match_globalenvs f2). eapply match_callstack_match_globalenvs; eauto.
- generalize (mg_functions _ H9 _ H8). intro.
+ generalize (mg_functions _ H7 _ H4). intro.
rewrite VF in VINJ1. inversion VINJ1. subst vf.
decEq. congruence.
- subst ofs2. replace x with 0. reflexivity. congruence.
+ subst ofs2. replace x1 with 0. reflexivity. congruence.
subst tv1. elim (functions_translated _ _ H3). intros tf [FIND TRF].
exploit H6; eauto.
intros [f4 [tm4 [tres [EVAL3 [VINJ3 [MINJ3 [INCR3 MATCH3]]]]]]].
exists f4; exists tm4; exists tres. intuition.
eapply eval_Ecall; eauto.
- rewrite <- H4. apply sig_preserved; auto.
+ apply sig_preserved; auto.
apply inject_incr_trans with f2; auto.
apply inject_incr_trans with f3; auto.
Qed.
@@ -1996,8 +1953,8 @@ Proof.
intros [f3 [tm3 [tv2 [EVAL2 [VINJ2 [MINJ2 [INCR2 MATCH2]]]]]]].
exists f3; exists tm3; exists tv2.
intuition.
- rewrite <- H6. subst t; eapply eval_conditionalexpr_true; eauto.
- inversion VINJ1; subst v1 tv1; simpl in H1; simpl; contradiction || auto.
+ eapply eval_Econdition with (b1 := true); eauto.
+ eapply val_inject_bool_of_val; eauto. apply Val.bool_of_true_val; eauto.
eapply inject_incr_trans; eauto.
Qed.
@@ -2021,8 +1978,8 @@ Proof.
intros [f3 [tm3 [tv2 [EVAL2 [VINJ2 [MINJ2 [INCR2 MATCH2]]]]]]].
exists f3; exists tm3; exists tv2.
intuition.
- rewrite <- H6. subst t; eapply eval_conditionalexpr_false; eauto.
- inversion VINJ1; subst v1 tv1; simpl in H1; simpl; contradiction || auto.
+ eapply eval_Econdition with (b1 := false); eauto.
+ eapply val_inject_bool_of_val; eauto. apply Val.bool_of_false_val; eauto.
eapply inject_incr_trans; eauto.
Qed.
@@ -2047,7 +2004,7 @@ Proof.
intros [f3 [tm3 [tv2 [EVAL2 [VINJ2 [MINJ2 [INCR2 MATCH2]]]]]]].
exists f3; exists tm3; exists tv2.
intuition.
- subst ta; eapply eval_Elet; eauto.
+ eapply eval_Elet; eauto.
eapply inject_incr_trans; eauto.
Qed.
@@ -2072,7 +2029,7 @@ Proof.
exploit val_list_inject_nth; eauto. intros [tv [A B]].
exists f1; exists tm1; exists tv.
intuition.
- subst ta. eapply eval_Eletvar; auto.
+ eapply eval_Eletvar; auto.
Qed.
Lemma transl_expr_Ealloc_correct:
@@ -2095,7 +2052,7 @@ Proof.
intros [MINJ3 INCR3].
exists (extend_inject b (Some (tb, 0)) f2);
exists tm3; exists (Vptr tb Int.zero).
- split. subst ta; econstructor; eauto.
+ split. econstructor; eauto.
split. econstructor. unfold extend_inject, eq_block. rewrite zeq_true. reflexivity.
reflexivity.
split. assumption.
@@ -2109,7 +2066,7 @@ Lemma transl_exprlist_Enil_correct:
Proof.
intros; red; intros. monadInv TR.
exists f1; exists tm1; exists (@nil val).
- intuition. subst tal; constructor.
+ intuition. constructor.
Qed.
Lemma transl_exprlist_Econs_correct:
@@ -2131,7 +2088,7 @@ Proof.
eauto. eapply val_list_inject_incr; eauto. eauto. eauto.
intros [f3 [tm3 [tv2 [EVAL2 [VINJ2 [MINJ3 [INCR3 MATCH3]]]]]]].
exists f3; exists tm3; exists (tv1 :: tv2).
- intuition. subst tal; econstructor; eauto.
+ intuition. econstructor; eauto.
constructor. eapply val_inject_incr; eauto. auto.
eapply inject_incr_trans; eauto.
Qed.
@@ -2149,15 +2106,11 @@ Lemma transl_funcall_internal_correct:
eval_funcall_prop m (Internal f) vargs t (free_list m3 lb) vres.
Proof.
intros; red. intros tfn f1 tm; intros.
- generalize TR; clear TR.
- unfold transl_fundef, transf_partial_fundef.
- caseEq (transl_function gce f); try congruence.
- intros tf TR EQ. inversion EQ; clear EQ; subst tfn.
- unfold transl_function in TR.
+ monadInv TR. generalize EQ.
+ unfold transl_function.
caseEq (build_compilenv gce f); intros cenv stacksize CENV.
- rewrite CENV in TR.
- destruct (zle stacksize Int.max_signed); try discriminate.
- monadInv TR. clear TR.
+ destruct (zle stacksize Int.max_signed); try congruence.
+ intro TR. monadInv TR.
caseEq (alloc tm 0 stacksize). intros tm1 sp ALLOC.
exploit function_entry_ok; eauto.
intros [f2 [te2 [tm2 [STOREPARAM [MINJ2 [INCR12 [MATCH2 BLOCKS]]]]]]].
@@ -2177,9 +2130,11 @@ Proof.
exists v2; split. auto. subst vres; auto.
contradiction.
destruct H5 as [tvres [TOUT VINJRES]].
+ assert (outcome_free_mem tout tm3 sp = Mem.free tm3 sp).
+ inversion OUTINJ; auto.
exists f3; exists (Mem.free tm3 sp); exists tvres.
(* execution *)
- split. rewrite <- H6; econstructor; simpl; eauto.
+ split. rewrite <- H5. econstructor; simpl; eauto.
apply exec_Sseq_continue with E0 te2 tm2 t.
exact STOREPARAM.
eexact EXECBODY.
@@ -2195,7 +2150,7 @@ Proof.
(* match_callstack *)
assert (forall bl mm, nextblock (free_list mm bl) = nextblock mm).
induction bl; intros. reflexivity. simpl. auto.
- unfold free; simpl nextblock. rewrite H5.
+ unfold free; simpl nextblock. rewrite H6.
eapply match_callstack_freelist; eauto.
intros. elim (BLOCKS b); intros B1 B2. generalize (B2 H7). omega.
Qed.
@@ -2206,8 +2161,7 @@ Lemma transl_funcall_external_correct:
event_match ef vargs t vres ->
eval_funcall_prop m (External ef) vargs t m vres.
Proof.
- intros; red; intros.
- simpl in TR. inversion TR; clear TR; subst tfn.
+ intros; red; intros. monadInv TR.
exploit event_match_inject; eauto. intros [A B].
exists f1; exists tm1; exists vres; intuition.
constructor; auto.
@@ -2219,7 +2173,7 @@ Lemma transl_stmt_Sskip_correct:
Proof.
intros; red; intros. monadInv TR.
exists f1; exists te1; exists tm1; exists Out_normal.
- intuition. subst ts; constructor. constructor.
+ intuition. constructor. constructor.
Qed.
Lemma transl_stmt_Sexpr_correct:
@@ -2233,7 +2187,7 @@ Proof.
exploit H0; eauto.
intros [f2 [tm2 [tv1 [EVAL1 [VINJ1 [MINJ2 [INCR2 MATCH2]]]]]]].
exists f2; exists te1; exists tm2; exists Out_normal.
- intuition. subst ts. econstructor; eauto.
+ intuition. econstructor; eauto.
constructor.
Qed.
@@ -2247,7 +2201,7 @@ Lemma transl_stmt_Sassign_correct:
store chunk m1 b 0 v = Some m2 ->
exec_stmt_prop e m (Csharpminor.Sassign id a) t m2 Csharpminor.Out_normal.
Proof.
- intros; red; intros. monadInv TR; intro EQ0.
+ intros; red; intros. monadInv TR.
exploit H0; eauto.
intros [f2 [tm2 [tv1 [EVAL1 [VINJ1 [MINJ1 [INCR12 MATCH1]]]]]]].
exploit var_set_correct; eauto.
@@ -2282,15 +2236,15 @@ Proof.
eapply val_inject_incr; eauto. eauto.
intros [tm4 [EVAL [MINJ4 NEXTBLOCK]]].
exists f3; exists te1; exists tm4; exists Out_normal.
- rewrite <- H6. subst t3. intuition.
+ intuition.
constructor.
eapply inject_incr_trans; eauto.
assert (val_inject f3 v1 tv1). eapply val_inject_incr; eauto.
unfold storev in H3; destruct v1; try discriminate.
inversion H4.
rewrite NEXTBLOCK. replace (nextblock m3) with (nextblock m2).
- eapply match_callstack_mapped; eauto. congruence.
- exploit store_inv; eauto. simpl; symmetry; tauto.
+ eapply match_callstack_mapped; eauto. congruence.
+ symmetry. eapply nextblock_store; eauto.
Qed.
Lemma transl_stmt_Sseq_continue_correct:
@@ -2309,7 +2263,7 @@ Proof.
exploit H2; eauto.
intros [f3 [te3 [tm3 [tout2 [EXEC2 [OINJ2 [MINJ3 [INCR3 MATCH3]]]]]]]].
exists f3; exists te3; exists tm3; exists tout2.
- intuition. subst ts; eapply exec_Sseq_continue; eauto.
+ intuition. eapply exec_Sseq_continue; eauto.
inversion OINJ1. subst tout1. auto.
eapply inject_incr_trans; eauto.
Qed.
@@ -2326,7 +2280,7 @@ Proof.
exploit H0; eauto.
intros [f2 [te2 [tm2 [tout1 [EXEC1 [OINJ1 [MINJ2 [INCR2 MATCH2]]]]]]]].
exists f2; exists te2; exists tm2; exists tout1.
- intuition. subst ts; eapply exec_Sseq_stop; eauto.
+ intuition. eapply exec_Sseq_stop; eauto.
inversion OINJ1; subst out tout1; congruence.
Qed.
@@ -2350,8 +2304,8 @@ Proof.
intros [f3 [te3 [tm3 [tout [EVAL2 [OINJ [MINJ3 [INCR3 MATCH3]]]]]]]].
exists f3; exists te3; exists tm3; exists tout.
intuition.
- subst ts t. eapply exec_ifthenelse_true; eauto.
- inversion VINJ1; subst v1 tv1; simpl in H1; simpl; contradiction || auto.
+ eapply exec_Sifthenelse with (b1 := true); eauto.
+ eapply val_inject_bool_of_val; eauto. apply Val.bool_of_true_val; auto.
eapply inject_incr_trans; eauto.
Qed.
@@ -2375,8 +2329,8 @@ Proof.
intros [f3 [te3 [tm3 [tout [EVAL2 [OINJ [MINJ3 [INCR3 MATCH3]]]]]]]].
exists f3; exists te3; exists tm3; exists tout.
intuition.
- subst ts t. eapply exec_ifthenelse_false; eauto.
- inversion VINJ1; subst v1 tv1; simpl in H1; simpl; contradiction || auto.
+ eapply exec_Sifthenelse with (b1 := false); eauto.
+ eapply val_inject_bool_of_val; eauto. apply Val.bool_of_false_val; auto.
eapply inject_incr_trans; eauto.
Qed.
@@ -2391,14 +2345,14 @@ Lemma transl_stmt_Sloop_loop_correct:
t = t1 ** t2 ->
exec_stmt_prop e m (Csharpminor.Sloop sl) t m2 out.
Proof.
- intros; red; intros. monadInv TR.
+ intros; red; intros. generalize TR; intro TR'; monadInv TR'.
exploit H0; eauto.
intros [f2 [te2 [tm2 [tout1 [EVAL1 [OINJ1 [MINJ2 [INCR2 MATCH2]]]]]]]].
exploit H2; eauto.
intros [f3 [te3 [tm3 [tout2 [EVAL2 [OINJ2 [MINJ3 [INCR3 MATCH3]]]]]]]].
exists f3; exists te3; exists tm3; exists tout2.
intuition.
- subst ts. eapply exec_Sloop_loop; eauto.
+ eapply exec_Sloop_loop; eauto.
inversion OINJ1; subst tout1; eauto.
eapply inject_incr_trans; eauto.
Qed.
@@ -2415,7 +2369,7 @@ Proof.
exploit H0; eauto.
intros [f2 [te2 [tm2 [tout1 [EVAL1 [OINJ1 [MINJ2 [INCR2 MATCH2]]]]]]]].
exists f2; exists te2; exists tm2; exists tout1.
- intuition. subst ts; eapply exec_Sloop_stop; eauto.
+ intuition. eapply exec_Sloop_stop; eauto.
inversion OINJ1; subst out tout1; congruence.
Qed.
@@ -2431,7 +2385,7 @@ Proof.
exploit H0; eauto.
intros [f2 [te2 [tm2 [tout1 [EVAL1 [OINJ1 [MINJ2 [INCR2 MATCH2]]]]]]]].
exists f2; exists te2; exists tm2; exists (outcome_block tout1).
- intuition. subst ts; eapply exec_Sblock; eauto.
+ intuition. eapply exec_Sblock; eauto.
inversion OINJ1; subst out tout1; simpl.
constructor.
destruct n; constructor.
@@ -2445,7 +2399,7 @@ Lemma transl_stmt_Sexit_correct:
Proof.
intros; red; intros. monadInv TR.
exists f1; exists te1; exists tm1; exists (Out_exit n).
- intuition. subst ts; constructor. constructor.
+ intuition. constructor. constructor.
Qed.
Lemma transl_stmt_Sswitch_correct:
@@ -2462,7 +2416,7 @@ Proof.
intros [f2 [tm2 [tv1 [EVAL [VINJ1 [MINJ2 [INCR MATCH2]]]]]]].
exists f2; exists te1; exists tm2;
exists (Out_exit (switch_target n default cases)). intuition.
- subst ts. constructor. inversion VINJ1. subst tv1. assumption.
+ constructor. inversion VINJ1. subst tv1. assumption.
constructor.
Qed.
@@ -2473,7 +2427,7 @@ Lemma transl_stmt_Sreturn_none_correct:
Proof.
intros; red; intros. monadInv TR.
exists f1; exists te1; exists tm1; exists (Out_return None).
- intuition. subst ts; constructor. constructor.
+ intuition. constructor. constructor.
Qed.
Lemma transl_stmt_Sreturn_some_correct:
@@ -2488,7 +2442,7 @@ Proof.
exploit H0; eauto.
intros [f2 [tm2 [tv1 [EVAL [VINJ1 [MINJ2 [INCR MATCH2]]]]]]].
exists f2; exists te1; exists tm2; exists (Out_return (Some tv1)).
- intuition. subst ts; econstructor; eauto. constructor; auto.
+ intuition. econstructor; eauto. constructor; auto.
Qed.
(** We conclude by an induction over the structure of the Csharpminor
@@ -2499,7 +2453,7 @@ Lemma transl_function_correct:
Csharpminor.eval_funcall prog m1 f vargs t m2 vres ->
eval_funcall_prop m1 f vargs t m2 vres.
Proof
- (eval_funcall_ind4 prog
+ (Csharpminor.eval_funcall_ind4 prog
eval_expr_prop
eval_exprlist_prop
eval_funcall_prop
@@ -2507,7 +2461,9 @@ Proof
transl_expr_Evar_correct
transl_expr_Eaddrof_correct
- transl_expr_Eop_correct
+ transl_expr_Econst_correct
+ transl_expr_Eunop_correct
+ transl_expr_Ebinop_correct
transl_expr_Eload_correct
transl_expr_Ecall_correct
transl_expr_Econdition_true_correct
@@ -2545,11 +2501,9 @@ Lemma match_globalenvs_init:
match_globalenvs f.
Proof.
intros. constructor.
- (* globalvars *)
- (* symbols *)
intros. split.
unfold f. rewrite zlt_true. auto. unfold m.
- eapply Genv.find_symbol_inv; eauto.
+ eapply Genv.find_symbol_not_fresh; eauto.
rewrite <- H. apply symbols_preserved.
intros. unfold f. rewrite zlt_true. auto.
generalize (nextblock_pos m). omega.
@@ -2566,20 +2520,10 @@ Proof.
intros t n [b [fn [m [FINDS [FINDF [SIG EVAL]]]]]].
elim (function_ptr_translated _ _ FINDF). intros tfn [TFIND TR].
set (m0 := Genv.init_mem prog) in *.
- set (f := fun b => if zlt b m0.(nextblock) then Some(b, 0) else None).
+ set (f := meminj_init m0).
assert (MINJ0: mem_inject f m0 m0).
- unfold f; constructor; intros.
- apply zlt_false; auto.
- destruct (zlt b0 (nextblock m0)); try discriminate.
- inversion H; subst b' delta.
- split. auto.
- constructor. compute. split; congruence. left; auto.
- intros; omega.
- generalize (Genv.initmem_block_init prog b0). fold m0. intros [idata EQ].
- rewrite EQ. simpl. apply Mem.contents_init_data_inject.
- destruct (zlt b1 (nextblock m0)); try discriminate.
- destruct (zlt b2 (nextblock m0)); try discriminate.
- left; congruence.
+ unfold f; apply init_inject.
+ unfold m0; apply Genv.initmem_inject_neutral.
assert (MATCH0: match_callstack f nil m0.(nextblock) m0.(nextblock) m0).
constructor. unfold f; apply match_globalenvs_init.
fold ge in EVAL.
diff --git a/cfrontend/Csem.v b/cfrontend/Csem.v
index 4cc85559c34a706e3cd782065097742e96ac099c..e24430cc072db7f1d0c525e9f5ebc805ef889f4a 100644
--- a/cfrontend/Csem.v
+++ b/cfrontend/Csem.v
@@ -1,6 +1,7 @@
(** * Dynamic semantics for the Clight language *)
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import Integers.
Require Import Floats.
@@ -559,7 +560,7 @@ with eval_lvalue: env -> mem -> expr -> trace -> mem -> block -> int -> Prop :=
| eval_Efield_struct: forall e m a t m1 l ofs id fList i ty delta,
eval_lvalue e m a t m1 l ofs ->
typeof a = Tstruct id fList ->
- field_offset i fList = Some delta ->
+ field_offset i fList = OK delta ->
eval_lvalue e m (Expr (Efield a i) ty)
t m1 l (Int.add ofs (Int.repr delta))
| eval_Efield_union: forall e m a t m1 l ofs id fList i ty,
diff --git a/cfrontend/Csharpminor.v b/cfrontend/Csharpminor.v
index f1d22d7ecbb0903ec2197c967a5efde7d3102107..729814ee716d6db9d7d1385c293aa15dc6fd228c 100644
--- a/cfrontend/Csharpminor.v
+++ b/cfrontend/Csharpminor.v
@@ -9,6 +9,7 @@ Require Import Values.
Require Import Mem.
Require Import Events.
Require Import Globalenvs.
+Require Cminor.
(** Abstract syntax *)
@@ -24,52 +25,21 @@ Require Import Globalenvs.
Unlike in Cminor (the next intermediate language of the back-end),
Csharpminor local variables reside in memory, and their address can
be taken using [Eaddrof] expressions.
+*)
+
+Inductive constant : Set :=
+ | Ointconst: int -> constant (**r integer constant *)
+ | Ofloatconst: float -> constant. (**r floating-point constant *)
- Another difference with Cminor is that Csharpminor is entirely
- processor-neutral. In particular, Csharpminor uses a standard set of
- operations: it does not reflect processor-specific operations nor
- addressing modes. *)
-
-Inductive operation : Set :=
- | Ointconst: int -> operation (**r integer constant *)
- | Ofloatconst: float -> operation (**r floating-point constant *)
- | Ocast8unsigned: operation (**r 8-bit zero extension *)
- | Ocast8signed: operation (**r 8-bit sign extension *)
- | Ocast16unsigned: operation (**r 16-bit zero extension *)
- | Ocast16signed: operation (**r 16-bit sign extension *)
- | Onotbool: operation (**r boolean negation *)
- | Onotint: operation (**r bitwise complement *)
- | Oadd: operation (**r integer addition *)
- | Osub: operation (**r integer subtraction *)
- | Omul: operation (**r integer multiplication *)
- | Odiv: operation (**r integer signed division *)
- | Odivu: operation (**r integer unsigned division *)
- | Omod: operation (**r integer signed modulus *)
- | Omodu: operation (**r integer unsigned modulus *)
- | Oand: operation (**r bitwise ``and'' *)
- | Oor: operation (**r bitwise ``or'' *)
- | Oxor: operation (**r bitwise ``xor'' *)
- | Oshl: operation (**r left shift *)
- | Oshr: operation (**r right signed shift *)
- | Oshru: operation (**r right unsigned shift *)
- | Onegf: operation (**r float opposite *)
- | Oabsf: operation (**r float absolute value *)
- | Oaddf: operation (**r float addition *)
- | Osubf: operation (**r float subtraction *)
- | Omulf: operation (**r float multiplication *)
- | Odivf: operation (**r float division *)
- | Osingleoffloat: operation (**r float truncation *)
- | Ointoffloat: operation (**r integer to float *)
- | Ofloatofint: operation (**r float to signed integer *)
- | Ofloatofintu: operation (**r float to unsigned integer *)
- | Ocmp: comparison -> operation (**r integer signed comparison *)
- | Ocmpu: comparison -> operation (**r integer unsigned comparison *)
- | Ocmpf: comparison -> operation. (**r float comparison *)
+Definition unary_operation : Set := Cminor.unary_operation.
+Definition binary_operation : Set := Cminor.binary_operation.
Inductive expr : Set :=
| Evar : ident -> expr (**r reading a scalar variable *)
| Eaddrof : ident -> expr (**r taking the address of a variable *)
- | Eop : operation -> exprlist -> expr (**r arithmetic operation *)
+ | Econst : constant -> expr
+ | Eunop : unary_operation -> expr -> expr
+ | Ebinop : binary_operation -> expr -> expr -> expr
| Eload : memory_chunk -> expr -> expr (**r memory read *)
| Ecall : signature -> expr -> exprlist -> expr (**r function call *)
| Econdition : expr -> expr -> expr -> expr (**r conditional expression *)
@@ -202,78 +172,15 @@ Definition global_var_env (p: program): gvarenv :=
(** Evaluation of operator applications. *)
-Definition eval_compare_null (c: comparison) (n: int) : option val :=
- if Int.eq n Int.zero
- then match c with Ceq => Some Vfalse | Cne => Some Vtrue | _ => None end
- else None.
-
-Definition eval_operation (op: operation) (vl: list val) (m: mem): option val :=
- match op, vl with
- | Ointconst n, nil => Some (Vint n)
- | Ofloatconst n, nil => Some (Vfloat n)
- | Ocast8unsigned, Vint n1 :: nil => Some (Vint (Int.cast8unsigned n1))
- | Ocast8signed, Vint n1 :: nil => Some (Vint (Int.cast8signed n1))
- | Ocast16unsigned, Vint n1 :: nil => Some (Vint (Int.cast16unsigned n1))
- | Ocast16signed, Vint n1 :: nil => Some (Vint (Int.cast16signed n1))
- | Onotbool, Vint n1 :: nil => Some (Val.of_bool (Int.eq n1 Int.zero))
- | Onotbool, Vptr b1 n1 :: nil => Some (Vfalse)
- | Onotint, Vint n1 :: nil => Some (Vint (Int.not n1))
- | Oadd, Vint n1 :: Vint n2 :: nil => Some (Vint (Int.add n1 n2))
- | Oadd, Vint n1 :: Vptr b2 n2 :: nil => Some (Vptr b2 (Int.add n2 n1))
- | Oadd, Vptr b1 n1 :: Vint n2 :: nil => Some (Vptr b1 (Int.add n1 n2))
- | Osub, Vint n1 :: Vint n2 :: nil => Some (Vint (Int.sub n1 n2))
- | Osub, Vptr b1 n1 :: Vint n2 :: nil => Some (Vptr b1 (Int.sub n1 n2))
- | Osub, Vptr b1 n1 :: Vptr b2 n2 :: nil =>
- if eq_block b1 b2 then Some (Vint (Int.sub n1 n2)) else None
- | Omul, Vint n1 :: Vint n2 :: nil => Some (Vint (Int.mul n1 n2))
- | Odiv, Vint n1 :: Vint n2 :: nil =>
- if Int.eq n2 Int.zero then None else Some (Vint (Int.divs n1 n2))
- | Odivu, Vint n1 :: Vint n2 :: nil =>
- if Int.eq n2 Int.zero then None else Some (Vint (Int.divu n1 n2))
- | Omod, Vint n1 :: Vint n2 :: nil =>
- if Int.eq n2 Int.zero then None else Some (Vint (Int.mods n1 n2))
- | Omodu, Vint n1 :: Vint n2 :: nil =>
- if Int.eq n2 Int.zero then None else Some (Vint (Int.modu n1 n2))
- | Oand, Vint n1 :: Vint n2 :: nil => Some (Vint (Int.and n1 n2))
- | Oor, Vint n1 :: Vint n2 :: nil => Some (Vint (Int.or n1 n2))
- | Oxor, Vint n1 :: Vint n2 :: nil => Some (Vint (Int.xor n1 n2))
- | Oshl, Vint n1 :: Vint n2 :: nil =>
- if Int.ltu n2 (Int.repr 32) then Some (Vint (Int.shl n1 n2)) else None
- | Oshr, Vint n1 :: Vint n2 :: nil =>
- if Int.ltu n2 (Int.repr 32) then Some (Vint (Int.shr n1 n2)) else None
- | Oshru, Vint n1 :: Vint n2 :: nil =>
- if Int.ltu n2 (Int.repr 32) then Some (Vint (Int.shru n1 n2)) else None
- | Onegf, Vfloat f1 :: nil => Some (Vfloat (Float.neg f1))
- | Oabsf, Vfloat f1 :: nil => Some (Vfloat (Float.abs f1))
- | Oaddf, Vfloat f1 :: Vfloat f2 :: nil => Some (Vfloat (Float.add f1 f2))
- | Osubf, Vfloat f1 :: Vfloat f2 :: nil => Some (Vfloat (Float.sub f1 f2))
- | Omulf, Vfloat f1 :: Vfloat f2 :: nil => Some (Vfloat (Float.mul f1 f2))
- | Odivf, Vfloat f1 :: Vfloat f2 :: nil => Some (Vfloat (Float.div f1 f2))
- | Osingleoffloat, Vfloat f1 :: nil =>
- Some (Vfloat (Float.singleoffloat f1))
- | Ointoffloat, Vfloat f1 :: nil =>
- Some (Vint (Float.intoffloat f1))
- | Ofloatofint, Vint n1 :: nil =>
- Some (Vfloat (Float.floatofint n1))
- | Ofloatofintu, Vint n1 :: nil =>
- Some (Vfloat (Float.floatofintu n1))
- | Ocmp c, Vint n1 :: Vint n2 :: nil =>
- Some (Val.of_bool(Int.cmp c n1 n2))
- | Ocmp c, Vptr b1 n1 :: Vptr b2 n2 :: nil =>
- if valid_pointer m b1 (Int.signed n1)
- && valid_pointer m b2 (Int.signed n2) then
- if eq_block b1 b2 then Some(Val.of_bool(Int.cmp c n1 n2)) else None
- else
- None
- | Ocmp c, Vptr b1 n1 :: Vint n2 :: nil => eval_compare_null c n2
- | Ocmp c, Vint n1 :: Vptr b2 n2 :: nil => eval_compare_null c n1
- | Ocmpu c, Vint n1 :: Vint n2 :: nil =>
- Some (Val.of_bool(Int.cmpu c n1 n2))
- | Ocmpf c, Vfloat f1 :: Vfloat f2 :: nil =>
- Some (Val.of_bool (Float.cmp c f1 f2))
- | _, _ => None
+Definition eval_constant (cst: constant) : option val :=
+ match cst with
+ | Ointconst n => Some (Vint n)
+ | Ofloatconst n => Some (Vfloat n)
end.
+Definition eval_unop := Cminor.eval_unop.
+Definition eval_binop := Cminor.eval_binop.
+
(** Allocation of local variables at function entry. Each variable is
bound to the reference to a fresh block of the appropriate size. *)
@@ -361,11 +268,22 @@ Inductive eval_expr:
forall le e m id b,
eval_var_addr e id b ->
eval_expr le e m (Eaddrof id) E0 m (Vptr b Int.zero)
- | eval_Eop:
- forall le e m op al t m1 vl v,
- eval_exprlist le e m al t m1 vl ->
- eval_operation op vl m1 = Some v ->
- eval_expr le e m (Eop op al) t m1 v
+ | eval_Econst:
+ forall le e m cst v,
+ eval_constant cst = Some v ->
+ eval_expr le e m (Econst cst) E0 m v
+ | eval_Eunop:
+ forall le e m op a t m1 v1 v,
+ eval_expr le e m a t m1 v1 ->
+ eval_unop op v1 = Some v ->
+ eval_expr le e m (Eunop op a) t m1 v
+ | eval_Ebinop:
+ forall le e m op a1 a2 t1 m1 v1 t2 m2 v2 t v,
+ eval_expr le e m a1 t1 m1 v1 ->
+ eval_expr le e m1 a2 t2 m2 v2 ->
+ eval_binop op v1 v2 m2 = Some v ->
+ t = t1 ** t2 ->
+ eval_expr le e m (Ebinop op a1 a2) t m2 v
| eval_Eload:
forall le e m chunk a t m1 v1 v,
eval_expr le e m a t m1 v1 ->
diff --git a/cfrontend/Cshmgen.v b/cfrontend/Cshmgen.v
index 664c6fc45922b3dc6c70e610e9347bf28cb6bf01..5ab685db48ba446a7aaf5333da7817e9cee89e91 100644
--- a/cfrontend/Cshmgen.v
+++ b/cfrontend/Cshmgen.v
@@ -1,19 +1,14 @@
Require Import Coqlib.
+Require Import Errors.
Require Import Integers.
Require Import Floats.
Require Import AST.
Require Import Csyntax.
+Require Import Cminor.
Require Import Csharpminor.
-(** The error monad *)
-
-Definition bind (A B: Set) (f: option A) (g: A -> option B) :=
- match f with None => None | Some x => g x end.
-
-Implicit Arguments bind [A B].
-
-Notation "'do' X <- A ; B" := (bind A (fun X => B))
- (at level 200, X ident, A at level 100, B at level 200).
+Open Local Scope string_scope.
+Open Local Scope error_monad_scope.
(** ** Operations on C types *)
@@ -22,28 +17,28 @@ Definition signature_of_function (f: Csyntax.function) : signature :=
(typlist_of_typelist (type_of_params (Csyntax.fn_params f)))
(opttyp_of_type (Csyntax.fn_return f)).
-Definition chunk_of_type (ty: type): option memory_chunk :=
+Definition chunk_of_type (ty: type): res memory_chunk :=
match access_mode ty with
- | By_value chunk => Some chunk
- | _ => None
+ | By_value chunk => OK chunk
+ | _ => Error (msg "Cshmgen.chunk_of_type")
end.
-Definition var_kind_of_type (ty: type): option var_kind :=
+Definition var_kind_of_type (ty: type): res var_kind :=
match ty with
- | Tint I8 Signed => Some(Vscalar Mint8signed)
- | Tint I8 Unsigned => Some(Vscalar Mint8unsigned)
- | Tint I16 Signed => Some(Vscalar Mint16signed)
- | Tint I16 Unsigned => Some(Vscalar Mint16unsigned)
- | Tint I32 _ => Some(Vscalar Mint32)
- | Tfloat F32 => Some(Vscalar Mfloat32)
- | Tfloat F64 => Some(Vscalar Mfloat64)
- | Tvoid => None
- | Tpointer _ => Some(Vscalar Mint32)
- | Tarray _ _ => Some(Varray (Csyntax.sizeof ty))
- | Tfunction _ _ => None
- | Tstruct _ fList => Some(Varray (Csyntax.sizeof ty))
- | Tunion _ fList => Some(Varray (Csyntax.sizeof ty))
- | Tcomp_ptr _ => Some(Vscalar Mint32)
+ | Tint I8 Signed => OK(Vscalar Mint8signed)
+ | Tint I8 Unsigned => OK(Vscalar Mint8unsigned)
+ | Tint I16 Signed => OK(Vscalar Mint16signed)
+ | Tint I16 Unsigned => OK(Vscalar Mint16unsigned)
+ | Tint I32 _ => OK(Vscalar Mint32)
+ | Tfloat F32 => OK(Vscalar Mfloat32)
+ | Tfloat F64 => OK(Vscalar Mfloat64)
+ | Tvoid => Error (msg "Cshmgen.var_kind_of_type(void)")
+ | Tpointer _ => OK(Vscalar Mint32)
+ | Tarray _ _ => OK(Varray (Csyntax.sizeof ty))
+ | Tfunction _ _ => Error (msg "Cshmgen.var_kind_of_type(function)")
+ | Tstruct _ fList => OK(Varray (Csyntax.sizeof ty))
+ | Tunion _ fList => OK(Varray (Csyntax.sizeof ty))
+ | Tcomp_ptr _ => OK(Vscalar Mint32)
end.
(** ** Csharpminor constructors *)
@@ -60,19 +55,14 @@ end.
denoting a case where the operation is not defined at the given types.
*)
-Definition make_intconst (n: int) := Eop (Ointconst n) Enil.
-
-Definition make_floatconst (f: float) := Eop (Ofloatconst f) Enil.
-
-Definition make_unop (op: operation) (e: expr) := Eop op (Econs e Enil).
+Definition make_intconst (n: int) := Econst (Ointconst n).
-Definition make_binop (op: operation) (e1 e2: expr) :=
- Eop op (Econs e1 (Econs e2 Enil)).
+Definition make_floatconst (f: float) := Econst (Ofloatconst f).
Definition make_floatofint (e: expr) (sg: signedness) :=
match sg with
- | Signed => make_unop Ofloatofint e
- | Unsigned => make_unop Ofloatofintu e
+ | Signed => Eunop Ofloatofint e
+ | Unsigned => Eunop Ofloatofintu e
end.
(* [make_boolean e ty] returns a Csharpminor expression that evaluates
@@ -84,98 +74,98 @@ Definition make_floatofint (e: expr) (sg: signedness) :=
*)
Definition make_boolean (e: expr) (ty: type) :=
match ty with
- | Tfloat _ => make_binop (Ocmpf Cne) e (make_floatconst Float.zero)
+ | Tfloat _ => Ebinop (Ocmpf Cne) e (make_floatconst Float.zero)
| _ => e
end.
Definition make_neg (e: expr) (ty: type) :=
match ty with
- | Tint _ _ => Some (make_binop Osub (make_intconst Int.zero) e)
- | Tfloat _ => Some (make_unop Onegf e)
- | _ => None
+ | Tint _ _ => OK (Eunop Onegint e)
+ | Tfloat _ => OK (Eunop Onegf e)
+ | _ => Error (msg "Cshmgen.make_neg")
end.
Definition make_notbool (e: expr) (ty: type) :=
match ty with
- | Tfloat _ => make_binop (Ocmpf Ceq) e (make_floatconst Float.zero)
- | _ => make_unop Onotbool e
+ | Tfloat _ => Ebinop (Ocmpf Ceq) e (make_floatconst Float.zero)
+ | _ => Eunop Onotbool e
end.
Definition make_notint (e: expr) (ty: type) :=
- make_unop Onotint e.
+ Eunop Onotint e.
Definition make_add (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
match classify_add ty1 ty2 with
- | add_case_ii => Some (make_binop Oadd e1 e2)
- | add_case_ff => Some (make_binop Oaddf e1 e2)
+ | add_case_ii => OK (Ebinop Oadd e1 e2)
+ | add_case_ff => OK (Ebinop Oaddf e1 e2)
| add_case_pi ty =>
let n := make_intconst (Int.repr (Csyntax.sizeof ty)) in
- Some (make_binop Oadd e1 (make_binop Omul n e2))
- | add_default => None
+ OK (Ebinop Oadd e1 (Ebinop Omul n e2))
+ | add_default => Error (msg "Cshmgen.make_add")
end.
Definition make_sub (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
match classify_sub ty1 ty2 with
- | sub_case_ii => Some (make_binop Osub e1 e2)
- | sub_case_ff => Some (make_binop Osubf e1 e2)
+ | sub_case_ii => OK (Ebinop Osub e1 e2)
+ | sub_case_ff => OK (Ebinop Osubf e1 e2)
| sub_case_pi ty =>
let n := make_intconst (Int.repr (Csyntax.sizeof ty)) in
- Some (make_binop Osub e1 (make_binop Omul n e2))
+ OK (Ebinop Osub e1 (Ebinop Omul n e2))
| sub_case_pp ty =>
let n := make_intconst (Int.repr (Csyntax.sizeof ty)) in
- Some (make_binop Odivu (make_binop Osub e1 e2) n)
- | sub_default => None
+ OK (Ebinop Odivu (Ebinop Osub e1 e2) n)
+ | sub_default => Error (msg "Cshmgen.make_sub")
end.
Definition make_mul (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
match classify_mul ty1 ty2 with
- | mul_case_ii => Some (make_binop Omul e1 e2)
- | mul_case_ff => Some (make_binop Omulf e1 e2)
- | mul_default => None
+ | mul_case_ii => OK (Ebinop Omul e1 e2)
+ | mul_case_ff => OK (Ebinop Omulf e1 e2)
+ | mul_default => Error (msg "Cshmgen.make_mul")
end.
Definition make_div (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
match classify_div ty1 ty2 with
- | div_case_I32unsi => Some (make_binop Odivu e1 e2)
- | div_case_ii => Some (make_binop Odiv e1 e2)
- | div_case_ff => Some (make_binop Odivf e1 e2)
- | div_default => None
+ | div_case_I32unsi => OK (Ebinop Odivu e1 e2)
+ | div_case_ii => OK (Ebinop Odiv e1 e2)
+ | div_case_ff => OK (Ebinop Odivf e1 e2)
+ | div_default => Error (msg "Cshmgen.make_div")
end.
Definition make_mod (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
match classify_mod ty1 ty2 with
- | mod_case_I32unsi => Some (make_binop Omodu e1 e2)
- | mod_case_ii=> Some (make_binop Omod e1 e2)
- | mod_default => None
+ | mod_case_I32unsi => OK (Ebinop Omodu e1 e2)
+ | mod_case_ii=> OK (Ebinop Omod e1 e2)
+ | mod_default => Error (msg "Cshmgen.make_mod")
end.
Definition make_and (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
- Some(make_binop Oand e1 e2).
+ OK(Ebinop Oand e1 e2).
Definition make_or (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
- Some(make_binop Oor e1 e2).
+ OK(Ebinop Oor e1 e2).
Definition make_xor (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
- Some(make_binop Oxor e1 e2).
+ OK(Ebinop Oxor e1 e2).
Definition make_shl (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
- Some(make_binop Oshl e1 e2).
+ OK(Ebinop Oshl e1 e2).
Definition make_shr (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
match classify_shr ty1 ty2 with
- | shr_case_I32unsi => Some (make_binop Oshru e1 e2)
- | shr_case_ii=> Some (make_binop Oshr e1 e2)
- | shr_default => None
+ | shr_case_I32unsi => OK (Ebinop Oshru e1 e2)
+ | shr_case_ii=> OK (Ebinop Oshr e1 e2)
+ | shr_default => Error (msg "Cshmgen.make_shr")
end.
Definition make_cmp (c: comparison) (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
match classify_cmp ty1 ty2 with
- | cmp_case_I32unsi => Some (make_binop (Ocmpu c) e1 e2)
- | cmp_case_ii => Some (make_binop (Ocmp c) e1 e2)
- | cmp_case_ff => Some (make_binop (Ocmpf c) e1 e2)
- | cmp_case_pi => Some (make_binop (Ocmp c) e1 e2)
- | cmp_case_pp => Some (make_binop (Ocmp c) e1 e2)
- | cmp_default => None
+ | cmp_case_I32unsi => OK (Ebinop (Ocmpu c) e1 e2)
+ | cmp_case_ii => OK (Ebinop (Ocmp c) e1 e2)
+ | cmp_case_ff => OK (Ebinop (Ocmpf c) e1 e2)
+ | cmp_case_pi => OK (Ebinop (Ocmp c) e1 e2)
+ | cmp_case_pp => OK (Ebinop (Ocmp c) e1 e2)
+ | cmp_default => Error (msg "Cshmgen.make_shr")
end.
Definition make_andbool (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
@@ -206,17 +196,17 @@ Definition make_orbool (e1: expr) (ty1: type) (e2: expr) (ty2: type) :=
Definition make_cast1 (from to: type) (e: expr) :=
match from, to with
| Tint _ uns, Tfloat _ => make_floatofint e uns
- | Tfloat _, Tint _ _ => make_unop Ointoffloat e
+ | Tfloat _, Tint _ _ => Eunop Ointoffloat e
| _, _ => e
end.
Definition make_cast2 (from to: type) (e: expr) :=
match to with
- | Tint I8 Signed => make_unop Ocast8signed e
- | Tint I8 Unsigned => make_unop Ocast8unsigned e
- | Tint I16 Signed => make_unop Ocast16signed e
- | Tint I16 Unsigned => make_unop Ocast16unsigned e
- | Tfloat F32 => make_unop Osingleoffloat e
+ | Tint I8 Signed => Eunop Ocast8signed e
+ | Tint I8 Unsigned => Eunop Ocast8unsigned e
+ | Tint I16 Signed => Eunop Ocast16signed e
+ | Tint I16 Unsigned => Eunop Ocast16unsigned e
+ | Tfloat F32 => Eunop Osingleoffloat e
| _ => e
end.
@@ -231,9 +221,9 @@ Definition make_cast (from to: type) (e: expr) :=
Definition make_load (addr: expr) (ty_res: type) :=
match (access_mode ty_res) with
- | By_value chunk => Some (Eload chunk addr)
- | By_reference => Some addr
- | By_nothing => None
+ | By_value chunk => OK (Eload chunk addr)
+ | By_reference => OK addr
+ | By_nothing => Error (msg "Cshmgen.make_load")
end.
(* [make_store addr ty_res rhs ty_rhs] stores the value of the
@@ -243,8 +233,8 @@ Definition make_load (addr: expr) (ty_res: type) :=
Definition make_store (addr: expr) (ty: type) (rhs: expr) :=
match access_mode ty with
- | By_value chunk => Some (Sstore chunk addr rhs)
- | _ => None
+ | By_value chunk => OK (Sstore chunk addr rhs)
+ | _ => Error (msg "Cshmgen.make_store")
end.
(** ** Reading and writing variables *)
@@ -258,9 +248,9 @@ Definition make_store (addr: expr) (ty: type) (rhs: expr) :=
Definition var_get (id: ident) (ty: type) :=
match access_mode ty with
- | By_value chunk => Some (Evar id)
- | By_reference => Some (Eaddrof id)
- | _ => None
+ | By_value chunk => OK (Evar id)
+ | By_reference => OK (Eaddrof id)
+ | _ => Error (MSG "Cshmgen.var_get " :: CTX id :: nil)
end.
(* [var_set id ty rhs] stores the value of the Csharpminor
@@ -269,21 +259,22 @@ Definition var_get (id: ident) (ty: type) :=
Definition var_set (id: ident) (ty: type) (rhs: expr) :=
match access_mode ty with
- | By_value chunk => Some (Sassign id rhs)
- | _ => None
+ | By_value chunk => OK (Sassign id rhs)
+ | _ => Error (MSG "Cshmgen.var_set " :: CTX id :: nil)
end.
(** ** Translation of operators *)
-Definition transl_unop (op: unary_operation) (a: expr) (ta: type) : option expr :=
+Definition transl_unop (op: Csyntax.unary_operation) (a: expr) (ta: type) : res expr :=
match op with
- | Csyntax.Onotbool => Some(make_notbool a ta)
- | Csyntax.Onotint => Some(make_notint a ta)
+ | Csyntax.Onotbool => OK(make_notbool a ta)
+ | Csyntax.Onotint => OK(make_notint a ta)
| Csyntax.Oneg => make_neg a ta
end.
-Definition transl_binop (op: binary_operation) (a: expr) (ta: type)
- (b: expr) (tb: type) : option expr :=
+Definition transl_binop (op: Csyntax.binary_operation)
+ (a: expr) (ta: type)
+ (b: expr) (tb: type) : res expr :=
match op with
| Csyntax.Oadd => make_add a ta b tb
| Csyntax.Osub => make_sub a ta b tb
@@ -315,12 +306,12 @@ Definition transl_binop (op: binary_operation) (a: expr) (ta: type)
a || b ---> a ? 1 : (b ? 1 : 0)
*)
-Fixpoint transl_expr (a: Csyntax.expr) {struct a} : option expr :=
+Fixpoint transl_expr (a: Csyntax.expr) {struct a} : res expr :=
match a with
| Expr (Csyntax.Econst_int n) _ =>
- Some(make_intconst n)
+ OK(make_intconst n)
| Expr (Csyntax.Econst_float n) _ =>
- Some(make_floatconst n)
+ OK(make_floatconst n)
| Expr (Csyntax.Evar id) ty =>
var_get id ty
| Expr (Csyntax.Ederef b) _ =>
@@ -337,7 +328,7 @@ Fixpoint transl_expr (a: Csyntax.expr) {struct a} : option expr :=
transl_binop op tb (typeof b) tc (typeof c)
| Expr (Csyntax.Ecast ty b) _ =>
do tb <- transl_expr b;
- Some (make_cast (typeof b) ty tb)
+ OK (make_cast (typeof b) ty tb)
| Expr (Csyntax.Eindex b c) ty =>
do tb <- transl_expr b;
do tc <- transl_expr c;
@@ -348,31 +339,33 @@ Fixpoint transl_expr (a: Csyntax.expr) {struct a} : option expr :=
| fun_case_f args res =>
do tb <- transl_expr b;
do tcl <- transl_exprlist cl;
- Some(Ecall (signature_of_type args res) tb tcl)
- | _ => None
+ OK(Ecall (signature_of_type args res) tb tcl)
+ | _ =>
+ Error(msg "Cshmgen.transl_expr(call)")
end
| Expr (Csyntax.Eandbool b c) _ =>
do tb <- transl_expr b;
do tc <- transl_expr c;
- Some(make_andbool tb (typeof b) tc (typeof c))
+ OK(make_andbool tb (typeof b) tc (typeof c))
| Expr (Csyntax.Eorbool b c) _ =>
do tb <- transl_expr b;
do tc <- transl_expr c;
- Some(make_orbool tb (typeof b) tc (typeof c))
+ OK(make_orbool tb (typeof b) tc (typeof c))
| Expr (Csyntax.Esizeof ty) _ =>
- Some(make_intconst (Int.repr (Csyntax.sizeof ty)))
+ OK(make_intconst (Int.repr (Csyntax.sizeof ty)))
| Expr (Csyntax.Efield b i) ty =>
match typeof b with
| Tstruct _ fld =>
do tb <- transl_lvalue b;
do ofs <- field_offset i fld;
make_load
- (make_binop Oadd tb (make_intconst (Int.repr ofs)))
+ (Ebinop Oadd tb (make_intconst (Int.repr ofs)))
ty
| Tunion _ fld =>
do tb <- transl_lvalue b;
make_load tb ty
- | _ => None
+ | _ =>
+ Error(msg "Cshmgen.transl_expr(field)")
end
end
@@ -381,10 +374,10 @@ Fixpoint transl_expr (a: Csyntax.expr) {struct a} : option expr :=
where the value of [a] is stored.
*)
-with transl_lvalue (a: Csyntax.expr) {struct a} : option expr :=
+with transl_lvalue (a: Csyntax.expr) {struct a} : res expr :=
match a with
| Expr (Csyntax.Evar id) _ =>
- Some (Eaddrof id)
+ OK (Eaddrof id)
| Expr (Csyntax.Ederef b) _ =>
transl_expr b
| Expr (Csyntax.Eindex b c) _ =>
@@ -396,25 +389,27 @@ with transl_lvalue (a: Csyntax.expr) {struct a} : option expr :=
| Tstruct _ fld =>
do tb <- transl_lvalue b;
do ofs <- field_offset i fld;
- Some (make_binop Oadd tb (make_intconst (Int.repr ofs)))
+ OK (Ebinop Oadd tb (make_intconst (Int.repr ofs)))
| Tunion _ fld =>
transl_lvalue b
- | _ => None
+ | _ =>
+ Error(msg "Cshmgen.transl_lvalue(field)")
end
- | _ => None
+ | _ =>
+ Error(msg "Cshmgen.transl_lvalue")
end
(* [transl_exprlist al] returns a list of Csharpminor expressions
that compute the values of the list [al] of Csyntax expressions.
Used for function applications. *)
-with transl_exprlist (al: Csyntax.exprlist): option exprlist :=
+with transl_exprlist (al: Csyntax.exprlist): res exprlist :=
match al with
- | Csyntax.Enil => Some Enil
+ | Csyntax.Enil => OK Enil
| Csyntax.Econs a1 a2 =>
do ta1 <- transl_expr a1;
do ta2 <- transl_exprlist a2;
- Some (Econs ta1 ta2)
+ OK (Econs ta1 ta2)
end.
(** ** Translation of statements *)
@@ -431,9 +426,9 @@ Definition is_variable (e: Csyntax.expr) : option ident :=
value of the CabsCoq expression [e] and performs an [exit 0] if [e]
evaluates to false.
*)
-Definition exit_if_false (e: Csyntax.expr) : option stmt :=
+Definition exit_if_false (e: Csyntax.expr) : res stmt :=
do te <- transl_expr e;
- Some(Sifthenelse
+ OK(Sifthenelse
(make_boolean te (typeof e))
Sskip
(Sexit 0%nat)).
@@ -497,13 +492,13 @@ Fixpoint switch_table (sl: labeled_statements) (k: nat) {struct sl} : list (int
| LScase ni _ rem => (ni, k) :: switch_table rem (k+1)
end.
-Fixpoint transl_statement (nbrk ncnt: nat) (s: Csyntax.statement) {struct s} : option stmt :=
+Fixpoint transl_statement (nbrk ncnt: nat) (s: Csyntax.statement) {struct s} : res stmt :=
match s with
| Csyntax.Sskip =>
- Some Sskip
+ OK Sskip
| Csyntax.Sexpr e =>
do te <- transl_expr e;
- Some (Sexpr te)
+ OK (Sexpr te)
| Csyntax.Sassign b c =>
match (is_variable b) with
| Some id =>
@@ -517,35 +512,35 @@ Fixpoint transl_statement (nbrk ncnt: nat) (s: Csyntax.statement) {struct s} : o
| Csyntax.Ssequence s1 s2 =>
do ts1 <- transl_statement nbrk ncnt s1;
do ts2 <- transl_statement nbrk ncnt s2;
- Some (Sseq ts1 ts2)
+ OK (Sseq ts1 ts2)
| Csyntax.Sifthenelse e s1 s2 =>
do te <- transl_expr e;
do ts1 <- transl_statement nbrk ncnt s1;
do ts2 <- transl_statement nbrk ncnt s2;
- Some (Sifthenelse (make_boolean te (typeof e)) ts1 ts2)
+ OK (Sifthenelse (make_boolean te (typeof e)) ts1 ts2)
| Csyntax.Swhile e s1 =>
do te <- exit_if_false e;
do ts1 <- transl_statement 1%nat 0%nat s1;
- Some (Sblock (Sloop (Sseq te (Sblock ts1))))
+ OK (Sblock (Sloop (Sseq te (Sblock ts1))))
| Csyntax.Sdowhile e s1 =>
do te <- exit_if_false e;
do ts1 <- transl_statement 1%nat 0%nat s1;
- Some (Sblock (Sloop (Sseq (Sblock ts1) te)))
+ OK (Sblock (Sloop (Sseq (Sblock ts1) te)))
| Csyntax.Sfor e1 e2 e3 s1 =>
do te1 <- transl_statement nbrk ncnt e1;
do te2 <- exit_if_false e2;
do te3 <- transl_statement nbrk ncnt e3;
do ts1 <- transl_statement 1%nat 0%nat s1;
- Some (Sseq te1 (Sblock (Sloop (Sseq te2 (Sseq (Sblock ts1) te3)))))
+ OK (Sseq te1 (Sblock (Sloop (Sseq te2 (Sseq (Sblock ts1) te3)))))
| Csyntax.Sbreak =>
- Some (Sexit nbrk)
+ OK (Sexit nbrk)
| Csyntax.Scontinue =>
- Some (Sexit ncnt)
+ OK (Sexit ncnt)
| Csyntax.Sreturn (Some e) =>
do te <- transl_expr e;
- Some (Sreturn (Some te))
+ OK (Sreturn (Some te))
| Csyntax.Sreturn None =>
- Some (Sreturn None)
+ OK (Sreturn None)
| Csyntax.Sswitch e sl =>
let cases := switch_table sl 0 in
let ncases := List.length cases in
@@ -554,11 +549,11 @@ Fixpoint transl_statement (nbrk ncnt: nat) (s: Csyntax.statement) {struct s} : o
end
with transl_lblstmts (nbrk ncnt: nat) (sl: labeled_statements) (body: stmt)
- {struct sl}: option stmt :=
+ {struct sl}: res stmt :=
match sl with
| LSdefault s =>
do ts <- transl_statement nbrk ncnt s;
- Some (Sblock (Sseq body ts))
+ OK (Sblock (Sseq body ts))
| LScase _ s rem =>
do ts <- transl_statement nbrk ncnt s;
transl_lblstmts (pred nbrk) (pred ncnt) rem (Sblock (Sseq body ts))
@@ -566,28 +561,31 @@ with transl_lblstmts (nbrk ncnt: nat) (sl: labeled_statements) (body: stmt)
(*** Translation of functions *)
+Definition prefix_var_name (id: ident) : errmsg :=
+ MSG "In local variable " :: CTX id :: MSG ":\n" :: nil.
+
Definition transl_params (l: list (ident * type)) :=
- AST.map_partial chunk_of_type l.
+ AST.map_partial prefix_var_name chunk_of_type l.
Definition transl_vars (l: list (ident * type)) :=
- AST.map_partial var_kind_of_type l.
+ AST.map_partial prefix_var_name var_kind_of_type l.
-Definition transl_function (f: Csyntax.function) : option function :=
+Definition transl_function (f: Csyntax.function) : res function :=
do tparams <- transl_params (Csyntax.fn_params f);
do tvars <- transl_vars (Csyntax.fn_vars f);
do tbody <- transl_statement 1%nat 0%nat (Csyntax.fn_body f);
- Some (mkfunction (signature_of_function f) tparams tvars tbody).
+ OK (mkfunction (signature_of_function f) tparams tvars tbody).
-Definition transl_fundef (f: Csyntax.fundef) : option fundef :=
+Definition transl_fundef (f: Csyntax.fundef) : res fundef :=
match f with
| Csyntax.Internal g =>
- do tg <- transl_function g; Some(AST.Internal tg)
+ do tg <- transl_function g; OK(AST.Internal tg)
| Csyntax.External id args res =>
- Some(AST.External (external_function id args res))
+ OK(AST.External (external_function id args res))
end.
(** ** Translation of programs *)
Definition transl_globvar (ty: type) := var_kind_of_type ty.
-Definition transl_program (p: Csyntax.program) : option program :=
+Definition transl_program (p: Csyntax.program) : res program :=
transform_partial_program2 transl_fundef transl_globvar p.
diff --git a/cfrontend/Cshmgenproof1.v b/cfrontend/Cshmgenproof1.v
index bee078240922fe7097e1225cf35f36da9ea85802..7ffd156c9ed6cec9cae2659f4bb2f7bbcf11462c 100644
--- a/cfrontend/Cshmgenproof1.v
+++ b/cfrontend/Cshmgenproof1.v
@@ -1,6 +1,7 @@
(** * Correctness of the C front end, part 1: syntactic properties *)
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import Integers.
Require Import Floats.
@@ -12,64 +13,28 @@ Require Import Globalenvs.
Require Import Csyntax.
Require Import Csem.
Require Import Ctyping.
+Require Import Cminor.
Require Import Csharpminor.
Require Import Cshmgen.
-(** Monadic simplification *)
-
-Ltac monadSimpl1 :=
- match goal with
- | [ |- (bind ?F ?G = Some ?X) -> _ ] =>
- unfold bind at 1;
- generalize (refl_equal F);
- pattern F at -1 in |- *;
- case F;
- [ (let EQ := fresh "EQ" in
- (intro; intro EQ; try monadSimpl1))
- | intro; intro; discriminate ]
- | [ |- (None = Some _) -> _ ] =>
- intro; discriminate
- | [ |- (Some _ = Some _) -> _ ] =>
- let h := fresh "H" in
- (intro h; injection h; intro; clear h)
- | [ |- (_ = Some _) -> _ ] =>
- let EQ := fresh "EQ" in intro EQ
- end.
-
-Ltac monadSimpl :=
- match goal with
- | [ |- (bind ?F ?G = Some ?X) -> _ ] => monadSimpl1
- | [ |- (None = Some _) -> _ ] => monadSimpl1
- | [ |- (Some _ = Some _) -> _ ] => monadSimpl1
- | [ |- (?F _ _ _ _ _ _ = Some _) -> _ ] => unfold F; fold F; monadSimpl1
- | [ |- (?F _ _ _ _ _ = Some _) -> _ ] => unfold F; fold F; monadSimpl1
- | [ |- (?F _ _ _ _ = Some _) -> _ ] => unfold F; fold F; monadSimpl1
- | [ |- (?F _ _ _ = Some _) -> _ ] => unfold F; fold F; monadSimpl1
- | [ |- (?F _ _ = Some _) -> _ ] => unfold F; fold F; monadSimpl1
- | [ |- (?F _ = Some _) -> _ ] => unfold F; fold F; monadSimpl1
- end.
-
-Ltac monadInv H :=
- generalize H; monadSimpl.
-
(** Operations on types *)
Lemma transl_fundef_sig1:
forall f tf args res,
- transl_fundef f = Some tf ->
+ transl_fundef f = OK tf ->
classify_fun (type_of_fundef f) = fun_case_f args res ->
funsig tf = signature_of_type args res.
Proof.
intros. destruct f; monadInv H.
- monadInv EQ. rewrite <- H2. rewrite <- H3. simpl.
+ monadInv EQ. simpl.
simpl in H0. inversion H0. reflexivity.
- rewrite <- H2. simpl.
+ simpl.
simpl in H0. congruence.
Qed.
Lemma transl_fundef_sig2:
forall f tf args res,
- transl_fundef f = Some tf ->
+ transl_fundef f = OK tf ->
type_of_fundef f = Tfunction args res ->
funsig tf = signature_of_type args res.
Proof.
@@ -80,7 +45,7 @@ Qed.
Lemma var_kind_by_value:
forall ty chunk,
access_mode ty = By_value chunk ->
- var_kind_of_type ty = Some(Vscalar chunk).
+ var_kind_of_type ty = OK(Vscalar chunk).
Proof.
intros ty chunk; destruct ty; simpl; try congruence.
destruct i; try congruence; destruct s; congruence.
@@ -89,7 +54,7 @@ Qed.
Lemma sizeof_var_kind_of_type:
forall ty vk,
- var_kind_of_type ty = Some vk ->
+ var_kind_of_type ty = OK vk ->
Csharpminor.sizeof vk = Csyntax.sizeof ty.
Proof.
intros ty vk.
@@ -103,35 +68,35 @@ Qed.
(** ** Some properties of the translation functions *)
Lemma map_partial_names:
- forall (A B: Set) (f: A -> option B)
+ forall (A B: Set) (f: A -> res B)
(l: list (ident * A)) (tl: list (ident * B)),
- map_partial f l = Some tl ->
+ map_partial prefix_var_name f l = OK tl ->
List.map (@fst ident B) tl = List.map (@fst ident A) l.
Proof.
induction l; simpl.
intros. inversion H. reflexivity.
intro tl. destruct a as [id x]. destruct (f x); try congruence.
- caseEq (map_partial f l); intros; try congruence.
- inversion H0; subst tl. simpl. decEq. auto.
+ caseEq (map_partial prefix_var_name f l); simpl; intros; try congruence.
+ inv H0. simpl. decEq. auto.
Qed.
Lemma map_partial_append:
- forall (A B: Set) (f: A -> option B)
+ forall (A B: Set) (f: A -> res B)
(l1 l2: list (ident * A)) (tl1 tl2: list (ident * B)),
- map_partial f l1 = Some tl1 ->
- map_partial f l2 = Some tl2 ->
- map_partial f (l1 ++ l2) = Some (tl1 ++ tl2).
+ map_partial prefix_var_name f l1 = OK tl1 ->
+ map_partial prefix_var_name f l2 = OK tl2 ->
+ map_partial prefix_var_name f (l1 ++ l2) = OK (tl1 ++ tl2).
Proof.
induction l1; intros until tl2; simpl.
intros. inversion H. simpl; auto.
destruct a as [id x]. destruct (f x); try congruence.
- caseEq (map_partial f l1); intros; try congruence.
- inversion H0. rewrite (IHl1 _ _ _ H H1). auto.
+ caseEq (map_partial prefix_var_name f l1); simpl; intros; try congruence.
+ inv H0. rewrite (IHl1 _ _ _ H H1). auto.
Qed.
Lemma transl_params_names:
forall vars tvars,
- transl_params vars = Some tvars ->
+ transl_params vars = OK tvars ->
List.map (@fst ident memory_chunk) tvars = Ctyping.var_names vars.
Proof.
exact (map_partial_names _ _ chunk_of_type).
@@ -139,7 +104,7 @@ Qed.
Lemma transl_vars_names:
forall vars tvars,
- transl_vars vars = Some tvars ->
+ transl_vars vars = OK tvars ->
List.map (@fst ident var_kind) tvars = Ctyping.var_names vars.
Proof.
exact (map_partial_names _ _ var_kind_of_type).
@@ -148,8 +113,8 @@ Qed.
Lemma transl_names_norepet:
forall params vars sg tparams tvars body,
list_norepet (var_names params ++ var_names vars) ->
- transl_params params = Some tparams ->
- transl_vars vars = Some tvars ->
+ transl_params params = OK tparams ->
+ transl_vars vars = OK tvars ->
let f := Csharpminor.mkfunction sg tparams tvars body in
list_norepet (fn_params_names f ++ fn_vars_names f).
Proof.
@@ -161,35 +126,35 @@ Qed.
Lemma transl_vars_append:
forall l1 l2 tl1 tl2,
- transl_vars l1 = Some tl1 -> transl_vars l2 = Some tl2 ->
- transl_vars (l1 ++ l2) = Some (tl1 ++ tl2).
+ transl_vars l1 = OK tl1 -> transl_vars l2 = OK tl2 ->
+ transl_vars (l1 ++ l2) = OK (tl1 ++ tl2).
Proof.
exact (map_partial_append _ _ var_kind_of_type).
Qed.
Lemma transl_params_vars:
forall params tparams,
- transl_params params = Some tparams ->
+ transl_params params = OK tparams ->
transl_vars params =
- Some (List.map (fun id_chunk => (fst id_chunk, Vscalar (snd id_chunk))) tparams).
+ OK (List.map (fun id_chunk => (fst id_chunk, Vscalar (snd id_chunk))) tparams).
Proof.
induction params; intro tparams; simpl.
intros. inversion H. reflexivity.
destruct a as [id x].
unfold chunk_of_type. caseEq (access_mode x); try congruence.
intros chunk AM.
- caseEq (transl_params params); intros; try congruence.
- inversion H0.
+ caseEq (transl_params params); simpl; intros; try congruence.
+ inv H0.
rewrite (var_kind_by_value _ _ AM).
rewrite (IHparams _ H). reflexivity.
Qed.
Lemma transl_fn_variables:
forall params vars sg tparams tvars body,
- transl_params params = Some tparams ->
- transl_vars vars = Some tvars ->
+ transl_params params = OK tparams ->
+ transl_vars vars = OK tvars ->
let f := Csharpminor.mkfunction sg tparams tvars body in
- transl_vars (params ++ vars) = Some (fn_variables f).
+ transl_vars (params ++ vars) = OK (fn_variables f).
Proof.
intros.
generalize (transl_params_vars _ _ H); intro.
@@ -212,35 +177,36 @@ Qed.
Lemma transl_expr_lvalue:
forall ge e m1 a ty t m2 loc ofs ta,
Csem.eval_lvalue ge e m1 (Expr a ty) t m2 loc ofs ->
- transl_expr (Expr a ty) = Some ta ->
- (exists id, a = Csyntax.Evar id /\ var_get id ty = Some ta) \/
- (exists tb, transl_lvalue (Expr a ty) = Some tb /\
- make_load tb ty = Some ta).
+ transl_expr (Expr a ty) = OK ta ->
+ (exists id, a = Csyntax.Evar id /\ var_get id ty = OK ta) \/
+ (exists tb, transl_lvalue (Expr a ty) = OK tb /\
+ make_load tb ty = OK ta).
Proof.
intros. inversion H; subst; clear H; simpl in H0.
left; exists id; auto.
left; exists id; auto.
- monadInv H0. right. exists e0; split; auto.
- simpl. monadInv H0. right. exists e2; split; auto.
- simpl. rewrite H6 in H0. rewrite H6.
- monadInv H0. right.
- exists (make_binop Oadd e0 (make_intconst (Int.repr z))). split; auto.
- simpl. rewrite H10 in H0. rewrite H10.
- monadInv H0. right.
- exists e0; auto.
+ monadInv H0. right. exists x; split; auto.
+ simpl. monadInv H0. right. exists x1; split; auto.
+ simpl. rewrite EQ; rewrite EQ1. simpl. auto.
+ rewrite H6 in H0. monadInv H0. right.
+ exists (Ebinop Oadd x (make_intconst (Int.repr x0))). split; auto.
+ simpl. rewrite H6. rewrite EQ. rewrite EQ1. auto.
+ rewrite H10 in H0. monadInv H0. right.
+ exists x; split; auto.
+ simpl. rewrite H10. auto.
Qed.
Lemma transl_stmt_Sfor_start:
forall nbrk ncnt s1 e2 s3 s4 ts,
- transl_statement nbrk ncnt (Sfor s1 e2 s3 s4) = Some ts ->
+ transl_statement nbrk ncnt (Sfor s1 e2 s3 s4) = OK ts ->
exists ts1, exists ts2,
ts = Sseq ts1 ts2
- /\ transl_statement nbrk ncnt s1 = Some ts1
- /\ transl_statement nbrk ncnt (Sfor Csyntax.Sskip e2 s3 s4) = Some (Sseq Sskip ts2).
+ /\ transl_statement nbrk ncnt s1 = OK ts1
+ /\ transl_statement nbrk ncnt (Sfor Csyntax.Sskip e2 s3 s4) = OK (Sseq Sskip ts2).
Proof.
- intros. monadInv H. simpl.
- exists s; exists (Sblock (Sloop (Sseq s0 (Sseq (Sblock s5) s2)))).
- intuition.
+ intros. monadInv H. econstructor; econstructor.
+ split. reflexivity. split. auto. simpl.
+ rewrite EQ1; rewrite EQ0; rewrite EQ2; auto.
Qed.
(** Properties related to switch constructs *)
diff --git a/cfrontend/Cshmgenproof2.v b/cfrontend/Cshmgenproof2.v
index 0458bd564ebc7c72eb9196aa10bc4a0d3d3979ac..8e2ce3036332d71556fff677f0ada42506d7d31e 100644
--- a/cfrontend/Cshmgenproof2.v
+++ b/cfrontend/Cshmgenproof2.v
@@ -1,6 +1,7 @@
(** * Correctness of the C front end, part 2: Csharpminor construction functions *)
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import Integers.
Require Import Floats.
@@ -12,6 +13,7 @@ Require Import Globalenvs.
Require Import Csyntax.
Require Import Csem.
Require Import Ctyping.
+Require Import Cminor.
Require Import Csharpminor.
Require Import Cshmgen.
Require Import Cshmgenproof1.
@@ -25,14 +27,14 @@ Variable tprog: Csharpminor.program.
Lemma transl_lblstmts_exit:
forall e m1 t m2 sl body n tsl nbrk ncnt,
exec_stmt tprog e m1 body t m2 (Out_exit (lblstmts_length sl + n)) ->
- transl_lblstmts nbrk ncnt sl body = Some tsl ->
+ transl_lblstmts nbrk ncnt sl body = OK tsl ->
exec_stmt tprog e m1 tsl t m2 (outcome_block (Out_exit n)).
Proof.
induction sl; intros.
simpl in H; simpl in H0; monadInv H0.
- rewrite <- H2. constructor. apply exec_Sseq_stop. auto. congruence.
+ constructor. apply exec_Sseq_stop. auto. congruence.
simpl in H; simpl in H0; monadInv H0.
- eapply IHsl with (body := Sblock (Sseq body s0)); eauto.
+ eapply IHsl with (body := Sblock (Sseq body x)); eauto.
change (Out_exit (lblstmts_length sl + n))
with (outcome_block (Out_exit (S (lblstmts_length sl + n)))).
constructor. apply exec_Sseq_stop. auto. congruence.
@@ -41,15 +43,15 @@ Qed.
Lemma transl_lblstmts_return:
forall e m1 t m2 sl body optv tsl nbrk ncnt,
exec_stmt tprog e m1 body t m2 (Out_return optv) ->
- transl_lblstmts nbrk ncnt sl body = Some tsl ->
+ transl_lblstmts nbrk ncnt sl body = OK tsl ->
exec_stmt tprog e m1 tsl t m2 (Out_return optv).
Proof.
induction sl; intros.
simpl in H; simpl in H0; monadInv H0.
- rewrite <- H2. change (Out_return optv) with (outcome_block (Out_return optv)).
+ change (Out_return optv) with (outcome_block (Out_return optv)).
constructor. apply exec_Sseq_stop. auto. congruence.
simpl in H; simpl in H0; monadInv H0.
- eapply IHsl with (body := Sblock (Sseq body s0)); eauto.
+ eapply IHsl with (body := Sblock (Sseq body x)); eauto.
change (Out_return optv) with (outcome_block (Out_return optv)).
constructor. apply exec_Sseq_stop. auto. congruence.
Qed.
@@ -61,41 +63,18 @@ Lemma make_intconst_correct:
forall n le e m1,
Csharpminor.eval_expr tprog le e m1 (make_intconst n) E0 m1 (Vint n).
Proof.
- intros. unfold make_intconst. econstructor. constructor. reflexivity.
+ intros. unfold make_intconst. econstructor. constructor.
Qed.
Lemma make_floatconst_correct:
forall n le e m1,
Csharpminor.eval_expr tprog le e m1 (make_floatconst n) E0 m1 (Vfloat n).
Proof.
- intros. unfold make_floatconst. econstructor. constructor. reflexivity.
-Qed.
-
-Lemma make_unop_correct:
- forall op le e m1 a ta m2 va v,
- Csharpminor.eval_expr tprog le e m1 a ta m2 va ->
- eval_operation op (va :: nil) m2 = Some v ->
- Csharpminor.eval_expr tprog le e m1 (make_unop op a) ta m2 v.
-Proof.
- intros. unfold make_unop. econstructor. econstructor. eauto. constructor.
- traceEq. auto.
-Qed.
-
-Lemma make_binop_correct:
- forall op le e m1 a ta m2 va b tb m3 vb t v,
- Csharpminor.eval_expr tprog le e m1 a ta m2 va ->
- Csharpminor.eval_expr tprog le e m2 b tb m3 vb ->
- eval_operation op (va :: vb :: nil) m3 = Some v ->
- t = ta ** tb ->
- Csharpminor.eval_expr tprog le e m1 (make_binop op a b) t m3 v.
-Proof.
- intros. unfold make_binop.
- econstructor. econstructor. eauto. econstructor. eauto. constructor.
- reflexivity. traceEq. auto.
+ intros. unfold make_floatconst. econstructor. constructor.
Qed.
Hint Resolve make_intconst_correct make_floatconst_correct
- make_unop_correct make_binop_correct: cshm.
+ eval_Eunop eval_Ebinop: cshm.
Hint Extern 2 (@eq trace _ _) => traceEq: cshm.
Remark Vtrue_is_true: Val.is_true Vtrue.
@@ -120,7 +99,7 @@ Proof.
destruct ty; simpl;
try (exists v; intuition; inversion VTRUE; simpl; auto; fail).
exists Vtrue; split.
- eapply make_binop_correct; eauto with cshm.
+ econstructor; eauto with cshm.
inversion VTRUE; simpl.
replace (Float.cmp Cne f0 Float.zero) with (negb (Float.cmp Ceq f0 Float.zero)).
rewrite Float.eq_zero_false. reflexivity. auto.
@@ -140,7 +119,7 @@ Proof.
destruct ty; simpl;
try (exists v; intuition; inversion VFALSE; simpl; auto; fail).
exists Vfalse; split.
- eapply make_binop_correct; eauto with cshm.
+ econstructor; eauto with cshm.
inversion VFALSE; simpl.
replace (Float.cmp Cne Float.zero Float.zero) with (negb (Float.cmp Ceq Float.zero Float.zero)).
rewrite Float.eq_zero_true. reflexivity.
@@ -151,13 +130,13 @@ Qed.
Lemma make_neg_correct:
forall a tya c ta va v le e m1 m2,
sem_neg va tya = Some v ->
- make_neg a tya = Some c ->
+ make_neg a tya = OK c ->
eval_expr tprog le e m1 a ta m2 va ->
eval_expr tprog le e m1 c ta m2 v.
Proof.
intros until m2; intro SEM. unfold make_neg.
functional inversion SEM; intros.
- inversion H4. eapply make_binop_correct; eauto with cshm.
+ inversion H4. econstructor; eauto with cshm.
inversion H4. eauto with cshm.
Qed.
@@ -186,21 +165,21 @@ Proof.
Qed.
Definition binary_constructor_correct
- (make: expr -> type -> expr -> type -> option expr)
+ (make: expr -> type -> expr -> type -> res expr)
(sem: val -> type -> val -> type -> option val): Prop :=
forall a tya b tyb c ta va tb vb v le e m1 m2 m3,
sem va tya vb tyb = Some v ->
- make a tya b tyb = Some c ->
+ make a tya b tyb = OK c ->
eval_expr tprog le e m1 a ta m2 va ->
eval_expr tprog le e m2 b tb m3 vb ->
eval_expr tprog le e m1 c (ta ** tb) m3 v.
Definition binary_constructor_correct'
- (make: expr -> type -> expr -> type -> option expr)
+ (make: expr -> type -> expr -> type -> res expr)
(sem: val -> val -> option val): Prop :=
forall a tya b tyb c ta va tb vb v le e m1 m2 m3,
sem va vb = Some v ->
- make a tya b tyb = Some c ->
+ make a tya b tyb = OK c ->
eval_expr tprog le e m1 a ta m2 va ->
eval_expr tprog le e m2 b tb m3 vb ->
eval_expr tprog le e m1 c (ta ** tb) m3 v.
@@ -212,8 +191,8 @@ Proof.
inversion H7. eauto with cshm.
inversion H7. eauto with cshm.
inversion H7.
- eapply make_binop_correct. eauto.
- eapply make_binop_correct. eauto with cshm. eauto.
+ econstructor. eauto.
+ econstructor. eauto with cshm. eauto.
simpl. reflexivity. reflexivity.
simpl. reflexivity. traceEq.
Qed.
@@ -223,12 +202,12 @@ Proof.
red; intros until m3. intro SEM. unfold make_sub.
functional inversion SEM; rewrite H0; intros;
inversion H7; eauto with cshm.
- eapply make_binop_correct. eauto.
- eapply make_binop_correct. eauto with cshm. eauto.
+ econstructor. eauto.
+ econstructor. eauto with cshm. eauto.
simpl. reflexivity. reflexivity.
simpl. reflexivity. traceEq.
- inversion H9. eapply make_binop_correct.
- eapply make_binop_correct; eauto.
+ inversion H9. econstructor.
+ econstructor; eauto.
simpl. unfold eq_block; rewrite H3. reflexivity.
eauto with cshm. simpl. rewrite H8. reflexivity. traceEq.
Qed.
@@ -244,9 +223,9 @@ Lemma make_div_correct: binary_constructor_correct make_div sem_div.
Proof.
red; intros until m3. intro SEM. unfold make_div.
functional inversion SEM; rewrite H0; intros.
- inversion H8. eapply make_binop_correct; eauto with cshm.
+ inversion H8. econstructor; eauto with cshm.
simpl. rewrite H7; auto.
- inversion H8. eapply make_binop_correct; eauto with cshm.
+ inversion H8. econstructor; eauto with cshm.
simpl. rewrite H7; auto.
inversion H7; eauto with cshm.
Qed.
@@ -254,9 +233,9 @@ Qed.
Lemma make_mod_correct: binary_constructor_correct make_mod sem_mod.
red; intros until m3. intro SEM. unfold make_mod.
functional inversion SEM; rewrite H0; intros.
- inversion H8. eapply make_binop_correct; eauto with cshm.
+ inversion H8. econstructor; eauto with cshm.
simpl. rewrite H7; auto.
- inversion H8. eapply make_binop_correct; eauto with cshm.
+ inversion H8. econstructor; eauto with cshm.
simpl. rewrite H7; auto.
Qed.
@@ -285,7 +264,7 @@ Lemma make_shl_correct: binary_constructor_correct' make_shl sem_shl.
Proof.
red; intros until m3. intro SEM. unfold make_shl.
functional inversion SEM. intros. inversion H5.
- eapply make_binop_correct; eauto with cshm.
+ econstructor; eauto with cshm.
simpl. rewrite H4. auto.
Qed.
@@ -293,16 +272,16 @@ Lemma make_shr_correct: binary_constructor_correct make_shr sem_shr.
Proof.
red; intros until m3. intro SEM. unfold make_shr.
functional inversion SEM; intros; rewrite H0 in H8; inversion H8.
- eapply make_binop_correct; eauto with cshm.
+ econstructor; eauto with cshm.
simpl; rewrite H7; auto.
- eapply make_binop_correct; eauto with cshm.
+ econstructor; eauto with cshm.
simpl; rewrite H7; auto.
Qed.
Lemma make_cmp_correct:
forall cmp a tya b tyb c ta va tb vb v le e m1 m2 m3,
sem_cmp cmp va tya vb tyb m3 = Some v ->
- make_cmp cmp a tya b tyb = Some c ->
+ make_cmp cmp a tya b tyb = OK c ->
eval_expr tprog le e m1 a ta m2 va ->
eval_expr tprog le e m2 b tb m3 vb ->
eval_expr tprog le e m1 c (ta ** tb) m3 v.
@@ -312,16 +291,16 @@ Proof.
inversion H8. eauto with cshm.
inversion H8. eauto with cshm.
inversion H8. eauto with cshm.
- inversion H9. eapply make_binop_correct; eauto with cshm.
+ inversion H9. econstructor; eauto with cshm.
simpl. functional inversion H; subst; unfold eval_compare_null;
rewrite H8; auto.
- inversion H10. eapply make_binop_correct; eauto with cshm.
+ inversion H10. econstructor; eauto with cshm.
simpl. rewrite H3. unfold eq_block; rewrite H9. auto.
Qed.
Lemma transl_unop_correct:
forall op a tya c ta va v le e m1 m2,
- transl_unop op a tya = Some c ->
+ transl_unop op a tya = OK c ->
sem_unary_operation op va tya = Some v ->
eval_expr tprog le e m1 a ta m2 va ->
eval_expr tprog le e m1 c ta m2 v.
@@ -334,7 +313,7 @@ Qed.
Lemma transl_binop_correct:
forall op a tya b tyb c ta va tb vb v le e m1 m2 m3,
- transl_binop op a tya b tyb = Some c ->
+ transl_binop op a tya b tyb = OK c ->
sem_binary_operation op va tya vb tyb m3 = Some v ->
eval_expr tprog le e m1 a ta m2 va ->
eval_expr tprog le e m2 b tb m3 vb ->
@@ -365,7 +344,7 @@ Lemma make_cast_correct:
cast v ty1 ty2 v' ->
eval_expr tprog le e m1 (make_cast ty1 ty2 a) t m2 v'.
Proof.
- unfold make_cast, make_cast1, make_cast2, make_unop.
+ unfold make_cast, make_cast1, make_cast2.
intros until v'; intros EVAL CAST.
inversion CAST; clear CAST; subst.
(* cast_int_int *)
@@ -373,7 +352,7 @@ Proof.
(* cast_float_int *)
destruct sz2; destruct si2; repeat econstructor; eauto with cshm; simpl; auto.
(* cast_int_float *)
- destruct sz2; destruct si1; unfold make_floatofint, make_unop; repeat econstructor; eauto with cshm; simpl; auto.
+ destruct sz2; destruct si1; unfold make_floatofint; repeat econstructor; eauto with cshm; simpl; auto.
(* cast_float_float *)
destruct sz2; repeat econstructor; eauto with cshm.
(* neutral, ptr *)
@@ -384,7 +363,7 @@ Qed.
Lemma make_load_correct:
forall addr ty code b ofs v le e m1 t m2,
- make_load addr ty = Some code ->
+ make_load addr ty = OK code ->
eval_expr tprog le e m1 addr t m2 (Vptr b ofs) ->
load_value_of_type ty m2 b ofs = Some v ->
eval_expr tprog le e m1 code t m2 v.
@@ -400,7 +379,7 @@ Qed.
Lemma make_store_correct:
forall addr ty rhs code e m1 t1 m2 b ofs t2 m3 v m4,
- make_store addr ty rhs = Some code ->
+ make_store addr ty rhs = OK code ->
eval_expr tprog nil e m1 addr t1 m2 (Vptr b ofs) ->
eval_expr tprog nil e m2 rhs t2 m3 v ->
store_value_of_type ty m3 b ofs v = Some m4 ->
diff --git a/cfrontend/Cshmgenproof3.v b/cfrontend/Cshmgenproof3.v
index 497286b3c11aa81059d5efd14ee1eb14cc4b0751..c8b9caf04dec5eea5ddb2648a08f3149f2da8ef5 100644
--- a/cfrontend/Cshmgenproof3.v
+++ b/cfrontend/Cshmgenproof3.v
@@ -1,6 +1,7 @@
(** * Correctness of the C front end, part 3: semantic preservation *)
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import Integers.
Require Import Floats.
@@ -12,6 +13,7 @@ Require Import Globalenvs.
Require Import Csyntax.
Require Import Csem.
Require Import Ctyping.
+Require Import Cminor.
Require Import Csharpminor.
Require Import Cshmgen.
Require Import Cshmgenproof1.
@@ -22,40 +24,26 @@ Section CORRECTNESS.
Variable prog: Csyntax.program.
Variable tprog: Csharpminor.program.
Hypothesis WTPROG: wt_program prog.
-Hypothesis TRANSL: transl_program prog = Some tprog.
+Hypothesis TRANSL: transl_program prog = OK tprog.
Let ge := Genv.globalenv prog.
Let tge := Genv.globalenv tprog.
Lemma symbols_preserved:
forall s, Genv.find_symbol tge s = Genv.find_symbol ge s.
-Proof.
- intros. unfold ge, tge.
- apply Genv.find_symbol_transf_partial2 with transl_fundef transl_globvar.
- auto.
-Qed.
+Proof (Genv.find_symbol_transf_partial2 transl_fundef transl_globvar _ TRANSL).
Lemma functions_translated:
forall v f,
Genv.find_funct ge v = Some f ->
- exists tf, Genv.find_funct tge v = Some tf /\ transl_fundef f = Some tf.
-Proof.
- intros.
- generalize (Genv.find_funct_transf_partial2 transl_fundef transl_globvar TRANSL H).
- intros [A B].
- destruct (transl_fundef f). exists f0; split. assumption. auto. congruence.
-Qed.
+ exists tf, Genv.find_funct tge v = Some tf /\ transl_fundef f = OK tf.
+Proof (Genv.find_funct_transf_partial2 transl_fundef transl_globvar TRANSL).
Lemma function_ptr_translated:
forall b f,
Genv.find_funct_ptr ge b = Some f ->
- exists tf, Genv.find_funct_ptr tge b = Some tf /\ transl_fundef f = Some tf.
-Proof.
- intros.
- generalize (Genv.find_funct_ptr_transf_partial2 transl_fundef transl_globvar TRANSL H).
- intros [A B].
- destruct (transl_fundef f). exists f0; split. assumption. auto. congruence.
-Qed.
+ exists tf, Genv.find_funct_ptr tge b = Some tf /\ transl_fundef f = OK tf.
+Proof (Genv.find_funct_ptr_transf_partial2 transl_fundef transl_globvar TRANSL).
Lemma functions_well_typed:
forall v f,
@@ -119,7 +107,7 @@ Proof.
Qed.
Lemma match_var_kind_of_type:
- forall ty vk, var_kind_of_type ty = Some vk -> match_var_kind ty vk.
+ forall ty vk, var_kind_of_type ty = OK vk -> match_var_kind ty vk.
Proof.
intros; red.
caseEq (access_mode ty); auto.
@@ -131,7 +119,7 @@ Lemma match_env_alloc_variables:
Csem.alloc_variables e1 m1 vars e2 m2 lb ->
forall tyenv te1 tvars,
match_env tyenv e1 te1 ->
- transl_vars vars = Some tvars ->
+ transl_vars vars = OK tvars ->
exists te2,
Csharpminor.alloc_variables te1 m1 tvars te2 m2 lb
/\ match_env (Ctyping.add_vars tyenv vars) e2 te2.
@@ -140,8 +128,8 @@ Proof.
simpl in H0. inversion H0; subst; clear H0.
exists te1; split. constructor. simpl. auto.
generalize H2. simpl.
- caseEq (var_kind_of_type ty); [intros vk VK | congruence].
- caseEq (transl_vars vars); [intros tvrs TVARS | congruence].
+ caseEq (var_kind_of_type ty); simpl; [intros vk VK | congruence].
+ caseEq (transl_vars vars); simpl; [intros tvrs TVARS | congruence].
intro EQ; inversion EQ; subst tvars; clear EQ.
set (te2 := PTree.set id (b1, vk) te1).
assert (match_env (add_var tyenv (id, ty)) (PTree.set id b1 e) te2).
@@ -168,14 +156,14 @@ Lemma bind_parameters_match_rec:
forall tyenv te tvars,
(forall id ty, In (id, ty) vars -> tyenv!id = Some ty) ->
match_env tyenv e te ->
- transl_params vars = Some tvars ->
+ transl_params vars = OK tvars ->
Csharpminor.bind_parameters te m1 tvars vals m2.
Proof.
induction 1; intros.
simpl in H1. inversion H1. constructor.
generalize H4; clear H4; simpl.
- caseEq (chunk_of_type ty); [intros chunk CHK | congruence].
- caseEq (transl_params params); [intros tparams TPARAMS | congruence].
+ caseEq (chunk_of_type ty); simpl; [intros chunk CHK | congruence].
+ caseEq (transl_params params); simpl; [intros tparams TPARAMS | congruence].
intro EQ; inversion EQ; clear EQ; subst tvars.
generalize CHK. unfold chunk_of_type.
caseEq (access_mode ty); intros; try discriminate.
@@ -215,7 +203,7 @@ Lemma bind_parameters_match:
Csem.bind_parameters e m1 params vals m2 ->
list_norepet (var_names params ++ var_names vars) ->
match_env (Ctyping.add_vars tyenv (params ++ vars)) e te ->
- transl_params params = Some tvars ->
+ transl_params params = OK tvars ->
Csharpminor.bind_parameters te m1 tvars vals m2.
Proof.
intros.
@@ -273,14 +261,14 @@ Qed.
Lemma add_global_var_match_globalenv:
forall vars tenv gv tvars,
match_globalenv tenv gv ->
- map_partial transl_globvar vars = Some tvars ->
+ map_partial AST.prefix_var_name transl_globvar vars = OK tvars ->
match_globalenv (add_global_vars tenv vars) (globvarenv gv tvars).
Proof.
induction vars; simpl.
intros. inversion H0. assumption.
destruct a as [[id init] ty]. intros until tvars; intro.
- caseEq (transl_globvar ty); try congruence. intros vk VK.
- caseEq (map_partial transl_globvar vars); try congruence. intros tvars' EQ1 EQ2.
+ caseEq (transl_globvar ty); simpl; try congruence. intros vk VK.
+ caseEq (map_partial AST.prefix_var_name transl_globvar vars); simpl; try congruence. intros tvars' EQ1 EQ2.
inversion EQ2; clear EQ2. simpl.
apply IHvars; auto.
red. intros until chunk. repeat rewrite PTree.gsspec.
@@ -299,7 +287,7 @@ Proof.
unfold global_typenv.
apply add_global_var_match_globalenv.
apply add_global_funs_match_global_env.
- unfold transl_program in TRANSL. functional inversion TRANSL. auto.
+ unfold transl_program in TRANSL. monadInv TRANSL. auto.
Qed.
(** ** Variable accessors *)
@@ -309,7 +297,7 @@ Lemma var_get_correct:
Csem.eval_lvalue ge e m (Expr (Csyntax.Evar id) ty) E0 m loc ofs ->
load_value_of_type ty m loc ofs = Some v ->
wt_expr tyenv (Expr (Csyntax.Evar id) ty) ->
- var_get id ty = Some code ->
+ var_get id ty = OK code ->
match_env tyenv e te ->
eval_expr tprog le te m code E0 m v.
Proof.
@@ -356,7 +344,7 @@ Lemma var_set_correct:
Csem.eval_lvalue ge e m (Expr (Csyntax.Evar id) ty) t1 m1 loc ofs ->
store_value_of_type ty m2 loc ofs v = Some m3 ->
wt_expr tyenv (Expr (Csyntax.Evar id) ty) ->
- var_set id ty rhs = Some code ->
+ var_set id ty rhs = OK code ->
match_env tyenv e te ->
eval_expr tprog nil te m1 rhs t2 m2 v ->
exec_stmt tprog te m code (t1 ** t2) m3 Out_normal.
@@ -394,7 +382,7 @@ Definition eval_expr_prop
(e: Csem.env) (m1: mem) (a: Csyntax.expr) (t: trace) (m2: mem) (v: val) : Prop :=
forall tyenv ta te tle
(WT: wt_expr tyenv a)
- (TR: transl_expr a = Some ta)
+ (TR: transl_expr a = OK ta)
(MENV: match_env tyenv e te),
Csharpminor.eval_expr tprog tle te m1 ta t m2 v.
@@ -403,7 +391,7 @@ Definition eval_lvalue_prop
(m2: mem) (b: block) (ofs: int) : Prop :=
forall tyenv ta te tle
(WT: wt_expr tyenv a)
- (TR: transl_lvalue a = Some ta)
+ (TR: transl_lvalue a = OK ta)
(MENV: match_env tyenv e te),
Csharpminor.eval_expr tprog tle te m1 ta t m2 (Vptr b ofs).
@@ -412,7 +400,7 @@ Definition eval_exprlist_prop
(m2: mem) (vl: list val) : Prop :=
forall tyenv tal te tle
(WT: wt_exprlist tyenv al)
- (TR: transl_exprlist al = Some tal)
+ (TR: transl_exprlist al = OK tal)
(MENV: match_env tyenv e te),
Csharpminor.eval_exprlist tprog tle te m1 tal t m2 vl.
@@ -429,7 +417,7 @@ Definition exec_stmt_prop
(m2: mem) (out: Csem.outcome) : Prop :=
forall tyenv nbrk ncnt ts te
(WT: wt_stmt tyenv s)
- (TR: transl_statement nbrk ncnt s = Some ts)
+ (TR: transl_statement nbrk ncnt s = OK ts)
(MENV: match_env tyenv e te),
Csharpminor.exec_stmt tprog te m1 ts t m2 (transl_outcome nbrk ncnt out).
@@ -440,7 +428,7 @@ Definition exec_lblstmts_prop
(WT: wt_lblstmts tyenv s)
(TR: transl_lblstmts (lblstmts_length s)
(1 + lblstmts_length s + ncnt)
- s body = Some ts)
+ s body = OK ts)
(MENV: match_env tyenv e te)
(BODY: Csharpminor.exec_stmt tprog te m0 body t0 m1 Out_normal),
Csharpminor.exec_stmt tprog te m0 ts (t0 ** t) m2
@@ -451,7 +439,7 @@ Definition eval_funcall_prop
(t: trace) (m2: mem) (res: val) : Prop :=
forall tf
(WT: wt_fundef (global_typenv prog) f)
- (TR: transl_fundef f = Some tf),
+ (TR: transl_fundef f = OK tf),
Csharpminor.eval_funcall tprog m1 tf params t m2 res.
(*
@@ -465,7 +453,7 @@ Lemma transl_Econst_int_correct:
eval_expr_prop e m (Expr (Econst_int i) ty) E0 m (Vint i)).
Proof.
intros; red; intros.
- monadInv TR. subst ta. apply make_intconst_correct.
+ monadInv TR. apply make_intconst_correct.
Qed.
Lemma transl_Econst_float_correct:
@@ -473,7 +461,7 @@ Lemma transl_Econst_float_correct:
eval_expr_prop e m (Expr (Econst_float f0) ty) E0 m (Vfloat f0)).
Proof.
intros; red; intros.
- monadInv TR. subst ta. apply make_floatconst_correct.
+ monadInv TR. apply make_floatconst_correct.
Qed.
Lemma transl_Elvalue_correct:
@@ -512,16 +500,16 @@ Lemma transl_Esizeof_correct:
eval_expr_prop e m (Expr (Esizeof ty') ty) E0 m
(Vint (Int.repr (Csyntax.sizeof ty')))).
Proof.
- intros; red; intros. monadInv TR. subst ta. apply make_intconst_correct.
+ intros; red; intros. monadInv TR. apply make_intconst_correct.
Qed.
Lemma transl_Eunop_correct:
- (forall (e : Csem.env) (m : mem) (op : unary_operation)
+ (forall (e : Csem.env) (m : mem) (op : Csyntax.unary_operation)
(a : Csyntax.expr) (ty : type) (t : trace) (m1 : mem) (v1 v : val),
Csem.eval_expr ge e m a t m1 v1 ->
eval_expr_prop e m a t m1 v1 ->
sem_unary_operation op v1 (typeof a) = Some v ->
- eval_expr_prop e m (Expr (Eunop op a) ty) t m1 v).
+ eval_expr_prop e m (Expr (Csyntax.Eunop op a) ty) t m1 v).
Proof.
intros; red; intros.
inversion WT; clear WT; subst.
@@ -530,7 +518,7 @@ Proof.
Qed.
Lemma transl_Ebinop_correct:
- (forall (e : Csem.env) (m : mem) (op : binary_operation)
+ (forall (e : Csem.env) (m : mem) (op : Csyntax.binary_operation)
(a1 a2 : Csyntax.expr) (ty : type) (t1 : trace) (m1 : mem)
(v1 : val) (t2 : trace) (m2 : mem) (v2 v : val),
Csem.eval_expr ge e m a1 t1 m1 v1 ->
@@ -538,7 +526,7 @@ Lemma transl_Ebinop_correct:
Csem.eval_expr ge e m1 a2 t2 m2 v2 ->
eval_expr_prop e m1 a2 t2 m2 v2 ->
sem_binary_operation op v1 (typeof a1) v2 (typeof a2) m2 = Some v ->
- eval_expr_prop e m (Expr (Ebinop op a1 a2) ty) (t1 ** t2) m2 v).
+ eval_expr_prop e m (Expr (Csyntax.Ebinop op a1 a2) ty) (t1 ** t2) m2 v).
Proof.
intros; red; intros.
inversion WT; clear WT; subst.
@@ -555,7 +543,7 @@ Lemma transl_Eorbool_1_correct:
eval_expr_prop e m (Expr (Eorbool a1 a2) ty) t m1 Vtrue).
Proof.
intros; red; intros. inversion WT; clear WT; subst. monadInv TR.
- rewrite <- H3; unfold make_orbool.
+ unfold make_orbool.
exploit make_boolean_correct_true; eauto. intros [vb [EVAL ISTRUE]].
eapply eval_Econdition_true; eauto.
unfold Vtrue; apply make_intconst_correct. traceEq.
@@ -574,7 +562,7 @@ Lemma transl_Eorbool_2_correct:
eval_expr_prop e m (Expr (Eorbool a1 a2) ty) (t1 ** t2) m2 v).
Proof.
intros; red; intros. inversion WT; clear WT; subst. monadInv TR.
- rewrite <- H6; unfold make_orbool.
+ unfold make_orbool.
exploit make_boolean_correct_false. eapply H0; eauto. eauto. intros [vb [EVAL ISFALSE]].
eapply eval_Econdition_false; eauto.
inversion H4; subst.
@@ -595,7 +583,7 @@ Lemma transl_Eandbool_1_correct:
eval_expr_prop e m (Expr (Eandbool a1 a2) ty) t m1 Vfalse).
Proof.
intros; red; intros. inversion WT; clear WT; subst. monadInv TR.
- rewrite <- H3; unfold make_andbool.
+ unfold make_andbool.
exploit make_boolean_correct_false; eauto. intros [vb [EVAL ISFALSE]].
eapply eval_Econdition_false; eauto.
unfold Vfalse; apply make_intconst_correct. traceEq.
@@ -614,7 +602,7 @@ Lemma transl_Eandbool_2_correct:
eval_expr_prop e m (Expr (Eandbool a1 a2) ty) (t1 ** t2) m2 v).
Proof.
intros; red; intros. inversion WT; clear WT; subst. monadInv TR.
- rewrite <- H6; unfold make_andbool.
+ unfold make_andbool.
exploit make_boolean_correct_true. eapply H0; eauto. eauto. intros [vb [EVAL ISTRUE]].
eapply eval_Econdition_true; eauto.
inversion H4; subst.
@@ -634,7 +622,7 @@ Lemma transl_Ecast_correct:
cast v1 (typeof a) ty v ->
eval_expr_prop e m (Expr (Ecast ty a) ty) t m1 v).
Proof.
- intros; red; intros. inversion WT; clear WT; subst. monadInv TR. subst ta.
+ intros; red; intros. inversion WT; clear WT; subst. monadInv TR.
eapply make_cast_correct; eauto.
Qed.
@@ -660,7 +648,7 @@ Proof.
caseEq (classify_fun (typeof a)).
2: intros; rewrite H7 in TR; discriminate.
intros targs tres EQ. rewrite EQ in TR.
- monadInv TR. clear TR. subst ta.
+ monadInv TR.
rewrite <- H4 in EQ.
exploit functions_translated; eauto. intros [tf [FIND TRL]].
econstructor.
@@ -679,7 +667,7 @@ Lemma transl_Evar_local_correct:
e ! id = Some l ->
eval_lvalue_prop e m (Expr (Csyntax.Evar id) ty) E0 m l Int.zero).
Proof.
- intros; red; intros. inversion WT; clear WT; subst. monadInv TR. subst ta.
+ intros; red; intros. inversion WT; clear WT; subst. monadInv TR.
exploit (me_local _ _ _ MENV); eauto. intros [vk [A B]].
econstructor. eapply eval_var_addr_local. eauto.
Qed.
@@ -691,7 +679,7 @@ Lemma transl_Evar_global_correct:
Genv.find_symbol ge id = Some l ->
eval_lvalue_prop e m (Expr (Csyntax.Evar id) ty) E0 m l Int.zero).
Proof.
- intros; red; intros. inversion WT; clear WT; subst. monadInv TR. subst ta.
+ intros; red; intros. inversion WT; clear WT; subst. monadInv TR.
exploit (me_global _ _ _ MENV); eauto. intros [A B].
econstructor. eapply eval_var_addr_global. eauto.
rewrite symbols_preserved. auto.
@@ -730,13 +718,13 @@ Lemma transl_Efield_struct_correct:
eval_lvalue ge e m a t m1 l ofs ->
eval_lvalue_prop e m a t m1 l ofs ->
typeof a = Tstruct id fList ->
- field_offset i fList = Some delta ->
+ field_offset i fList = OK delta ->
eval_lvalue_prop e m (Expr (Efield a i) ty) t m1 l
(Int.add ofs (Int.repr delta))).
Proof.
intros; red; intros. inversion WT; clear WT; subst.
simpl in TR. rewrite H1 in TR. monadInv TR.
- rewrite <- H5. eapply make_binop_correct; eauto.
+ econstructor; eauto.
apply make_intconst_correct.
simpl. congruence. traceEq.
Qed.
@@ -758,7 +746,7 @@ Lemma transl_Enil_correct:
(forall (e : Csem.env) (m : mem),
eval_exprlist_prop e m Csyntax.Enil E0 m nil).
Proof.
- intros; red; intros. monadInv TR. subst tal. constructor.
+ intros; red; intros. monadInv TR. constructor.
Qed.
Lemma transl_Econs_correct:
@@ -772,14 +760,14 @@ Lemma transl_Econs_correct:
eval_exprlist_prop e m (Csyntax.Econs a bl) (t1 ** t2) m2 (v :: vl)).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst tal. econstructor; eauto.
+ econstructor; eauto.
Qed.
Lemma transl_Sskip_correct:
(forall (e : Csem.env) (m : mem),
exec_stmt_prop e m Csyntax.Sskip E0 m Csem.Out_normal).
Proof.
- intros; red; intros. monadInv TR. subst ts. simpl. constructor.
+ intros; red; intros. monadInv TR. simpl. constructor.
Qed.
Lemma transl_Sexpr_correct:
@@ -790,8 +778,7 @@ Lemma transl_Sexpr_correct:
exec_stmt_prop e m (Csyntax.Sexpr a) t m1 Csem.Out_normal).
Proof.
intros; red; intros; simpl. inversion WT; clear WT; subst.
- monadInv TR. subst ts.
- econstructor; eauto.
+ monadInv TR. econstructor; eauto.
Qed.
Lemma transl_Sassign_correct:
@@ -831,7 +818,7 @@ Lemma transl_Ssequence_1_correct:
exec_stmt_prop e m (Ssequence s1 s2) (t1 ** t2) m2 out).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. red in H0; simpl in H0. eapply exec_Sseq_continue; eauto.
+ red in H0; simpl in H0. eapply exec_Sseq_continue; eauto.
Qed.
Lemma transl_Ssequence_2_correct:
@@ -843,7 +830,7 @@ Lemma transl_Ssequence_2_correct:
exec_stmt_prop e m (Ssequence s1 s2) t1 m1 out).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. eapply exec_Sseq_stop; eauto.
+ eapply exec_Sseq_stop; eauto.
destruct out; simpl; congruence.
Qed.
@@ -860,7 +847,7 @@ Lemma transl_Sifthenelse_true_correct:
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
exploit make_boolean_correct_true. eapply H0; eauto. eauto. intros [vb [EVAL ISTRUE]].
- subst ts. eapply exec_Sifthenelse_true; eauto.
+ eapply exec_Sifthenelse_true; eauto.
Qed.
Lemma transl_Sifthenelse_false_correct:
@@ -876,7 +863,7 @@ Lemma transl_Sifthenelse_false_correct:
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
exploit make_boolean_correct_false. eapply H0; eauto. eauto. intros [vb [EVAL ISFALSE]].
- subst ts. eapply exec_Sifthenelse_false; eauto.
+ eapply exec_Sifthenelse_false; eauto.
Qed.
Lemma transl_Sreturn_none_correct:
@@ -884,7 +871,7 @@ Lemma transl_Sreturn_none_correct:
exec_stmt_prop e m (Csyntax.Sreturn None) E0 m (Csem.Out_return None)).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. simpl. apply exec_Sreturn_none.
+ simpl. apply exec_Sreturn_none.
Qed.
Lemma transl_Sreturn_some_correct:
@@ -896,7 +883,7 @@ Lemma transl_Sreturn_some_correct:
(Csem.Out_return (Some v))).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. simpl. eapply exec_Sreturn_some; eauto.
+ simpl. eapply exec_Sreturn_some; eauto.
Qed.
Lemma transl_Sbreak_correct:
@@ -904,7 +891,7 @@ Lemma transl_Sbreak_correct:
exec_stmt_prop e m Sbreak E0 m Out_break).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. simpl. apply exec_Sexit.
+ simpl. apply exec_Sexit.
Qed.
Lemma transl_Scontinue_correct:
@@ -912,19 +899,19 @@ Lemma transl_Scontinue_correct:
exec_stmt_prop e m Scontinue E0 m Out_continue).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. simpl. apply exec_Sexit.
+ simpl. apply exec_Sexit.
Qed.
Lemma exit_if_false_true:
forall a ts e m1 t m2 v tyenv te,
- exit_if_false a = Some ts ->
+ exit_if_false a = OK ts ->
eval_expr_prop e m1 a t m2 v ->
match_env tyenv e te ->
wt_expr tyenv a ->
is_true v (typeof a) ->
exec_stmt tprog te m1 ts t m2 Out_normal.
Proof.
- intros. monadInv H. rewrite <- H5.
+ intros. monadInv H.
exploit make_boolean_correct_true. eapply H0; eauto. eauto.
intros [vb [EVAL ISTRUE]].
eapply exec_Sifthenelse_true with (v1 := vb); eauto.
@@ -933,14 +920,14 @@ Qed.
Lemma exit_if_false_false:
forall a ts e m1 t m2 v tyenv te,
- exit_if_false a = Some ts ->
+ exit_if_false a = OK ts ->
eval_expr_prop e m1 a t m2 v ->
match_env tyenv e te ->
wt_expr tyenv a ->
is_false v (typeof a) ->
exec_stmt tprog te m1 ts t m2 (Out_exit 0).
Proof.
- intros. monadInv H. rewrite <- H5.
+ intros. monadInv H.
exploit make_boolean_correct_false. eapply H0; eauto. eauto.
intros [vb [EVAL ISFALSE]].
eapply exec_Sifthenelse_false with (v1 := vb); eauto.
@@ -956,7 +943,7 @@ Lemma transl_Swhile_false_correct:
exec_stmt_prop e m (Swhile a s) t m1 Csem.Out_normal).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. simpl.
+ simpl.
change Out_normal with (outcome_block (Out_exit 0)).
apply exec_Sblock. apply exec_Sloop_stop. apply exec_Sseq_stop.
eapply exit_if_false_false; eauto. congruence. congruence.
@@ -992,7 +979,7 @@ Lemma transl_Swhile_stop_correct:
exec_stmt_prop e m (Swhile a s) (t1 ** t2) m2 out).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. rewrite (transl_out_break_or_return _ _ nbrk ncnt H4).
+ rewrite (transl_out_break_or_return _ _ nbrk ncnt H4).
apply exec_Sblock. apply exec_Sloop_stop.
eapply exec_Sseq_continue.
eapply exit_if_false_true; eauto.
@@ -1017,7 +1004,6 @@ Proof.
intros; red; intros.
exploit H6; eauto. intro NEXTITER.
inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts.
inversion NEXTITER; subst.
apply exec_Sblock.
eapply exec_Sloop_loop. eapply exec_Sseq_continue.
@@ -1041,7 +1027,7 @@ Lemma transl_Sdowhile_false_correct:
exec_stmt_prop e m (Sdowhile a s) (t1 ** t2) m2 Csem.Out_normal).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. simpl.
+ simpl.
change Out_normal with (outcome_block (Out_exit 0)).
apply exec_Sblock. apply exec_Sloop_stop. eapply exec_Sseq_continue.
rewrite (transl_out_normal_or_continue out1 H1).
@@ -1058,7 +1044,7 @@ Lemma transl_Sdowhile_stop_correct:
exec_stmt_prop e m (Sdowhile a s) t m1 out).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. simpl.
+ simpl.
assert (outcome_block (transl_outcome 1 0 out1) <> Out_normal).
inversion H1; simpl; congruence.
rewrite (transl_out_break_or_return _ _ nbrk ncnt H1).
@@ -1084,7 +1070,6 @@ Proof.
intros; red; intros.
exploit H6; eauto. intro NEXTITER.
inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts.
inversion NEXTITER; subst.
apply exec_Sblock.
eapply exec_Sloop_loop. eapply exec_Sseq_continue.
@@ -1129,7 +1114,7 @@ Lemma transl_Sfor_false_correct:
exec_stmt_prop e m (Sfor Csyntax.Sskip a2 a3 s) t m1 Csem.Out_normal).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. simpl.
+ simpl.
eapply exec_Sseq_continue. apply exec_Sskip.
change Out_normal with (outcome_block (Out_exit 0)).
apply exec_Sblock. apply exec_Sloop_stop.
@@ -1150,7 +1135,7 @@ Lemma transl_Sfor_stop_correct:
exec_stmt_prop e m (Sfor Csyntax.Sskip a2 a3 s) (t1 ** t2) m2 out).
Proof.
intros; red; intros. inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts. simpl.
+ simpl.
assert (outcome_block (transl_outcome 1 0 out2) <> Out_normal).
inversion H4; simpl; congruence.
rewrite (transl_out_break_or_return _ _ nbrk ncnt H4).
@@ -1181,7 +1166,6 @@ Proof.
intros; red; intros.
exploit H8; eauto. intro NEXTITER.
inversion WT; clear WT; subst. simpl in TR; monadInv TR.
- subst ts.
inversion NEXTITER; subst.
inversion H11; subst.
inversion H18; subst.
@@ -1205,7 +1189,7 @@ Lemma transl_lblstmts_switch:
transl_lblstmts
(lblstmts_length sl)
(S (lblstmts_length sl + ncnt))
- sl (Sblock body) = Some ts ->
+ sl (Sblock body) = OK ts ->
wt_lblstmts tyenv sl ->
match_env tyenv e te ->
exec_lblstmts_prop e m1 (select_switch n sl) t2 m2 out ->
@@ -1226,7 +1210,7 @@ Proof.
(* next case selected *)
inversion H1; clear H1; subst.
simpl in H0; monadInv H0.
- eapply IHsl with (body := Sseq (Sblock body) s0); eauto.
+ eapply IHsl with (body := Sseq (Sblock body) x); eauto.
apply exec_Sseq_stop.
change (Out_exit (switch_target n (lblstmts_length sl) (switch_table sl 0)))
with (outcome_block (Out_exit (S (switch_target n (lblstmts_length sl) (switch_table sl 0))))).
@@ -1247,7 +1231,7 @@ Lemma transl_Sswitch_correct:
Proof.
intros; red; intros.
inversion WT; clear WT; subst.
- simpl in TR. monadInv TR; clear TR.
+ simpl in TR. monadInv TR.
rewrite length_switch_table in EQ0.
replace (ncnt + lblstmts_length sl + 1)%nat
with (S (lblstmts_length sl + ncnt))%nat in EQ0 by omega.
@@ -1265,7 +1249,6 @@ Proof.
intros; red; intros.
inversion WT; subst.
simpl in TR. monadInv TR.
- rewrite <- H3.
replace (transl_outcome nbrk ncnt (outcome_switch out))
with (outcome_block (transl_outcome 0 (S ncnt) out)).
constructor.
@@ -1286,8 +1269,8 @@ Lemma transl_LScase_fallthrough_correct:
Proof.
intros; red; intros.
inversion WT; subst.
- simpl in TR. monadInv TR; clear TR.
- assert (exec_stmt tprog te m0 (Sblock (Sseq body s0))
+ monadInv TR.
+ assert (exec_stmt tprog te m0 (Sblock (Sseq body x))
(t0 ** t1) m1 Out_normal).
change Out_normal with
(outcome_block (transl_outcome (S (lblstmts_length ls))
@@ -1311,19 +1294,19 @@ Lemma transl_LScase_stop_correct:
Proof.
intros; red; intros.
inversion WT; subst.
- simpl in TR. monadInv TR; clear TR.
+ monadInv TR.
exploit H0; eauto. intro EXEC.
destruct out; simpl; simpl in EXEC.
(* out = Out_break *)
change Out_normal with (outcome_block (Out_exit 0)).
- eapply transl_lblstmts_exit with (body := Sblock (Sseq body s0)); eauto.
+ eapply transl_lblstmts_exit with (body := Sblock (Sseq body x)); eauto.
rewrite plus_0_r.
change (Out_exit (lblstmts_length ls))
with (outcome_block (Out_exit (S (lblstmts_length ls)))).
constructor. eapply exec_Sseq_continue; eauto.
(* out = Out_continue *)
change (Out_exit ncnt) with (outcome_block (Out_exit (S ncnt))).
- eapply transl_lblstmts_exit with (body := Sblock (Sseq body s0)); eauto.
+ eapply transl_lblstmts_exit with (body := Sblock (Sseq body x)); eauto.
replace (Out_exit (lblstmts_length ls + S ncnt))
with (outcome_block (Out_exit (S (S (lblstmts_length ls + ncnt))))).
constructor. eapply exec_Sseq_continue; eauto.
@@ -1331,7 +1314,7 @@ Proof.
(* out = Out_normal *)
congruence.
(* out = Out_return *)
- eapply transl_lblstmts_return with (body := Sblock (Sseq body s0)); eauto.
+ eapply transl_lblstmts_return with (body := Sblock (Sseq body x)); eauto.
change (Out_return o)
with (outcome_block (Out_return o)).
constructor. eapply exec_Sseq_continue; eauto.
@@ -1366,13 +1349,13 @@ Proof.
inversion WT; clear WT; subst.
inversion H6; clear H6; subst.
(* Exploitation of translation hypothesis *)
- monadInv TR. subst tf. clear TR.
- monadInv EQ. clear EQ. subst f0.
+ monadInv TR.
+ monadInv EQ.
(* Allocation of variables *)
exploit match_env_alloc_variables; eauto.
apply match_globalenv_match_env_empty.
apply match_global_typenv.
- eexact (transl_fn_variables _ _ (signature_of_function f) _ _ s EQ0 EQ1).
+ eexact (transl_fn_variables _ _ (signature_of_function f) _ _ x2 EQ0 EQ).
intros [te [ALLOCVARS MATCHENV]].
(* Execution *)
econstructor; simpl.
@@ -1395,7 +1378,7 @@ Lemma transl_funcall_external_correct:
eval_funcall_prop m (External id targs tres) vargs t m vres).
Proof.
intros; red; intros.
- monadInv TR. subst tf. constructor. auto.
+ monadInv TR. constructor. auto.
Qed.
Theorem transl_funcall_correct:
@@ -1467,7 +1450,7 @@ End CORRECTNESS.
Theorem transl_program_correct:
forall prog tprog t r,
- transl_program prog = Some tprog ->
+ transl_program prog = OK tprog ->
Ctyping.wt_program prog ->
Csem.exec_program prog t r ->
Csharpminor.exec_program tprog t r.
diff --git a/cfrontend/Csyntax.v b/cfrontend/Csyntax.v
index f9463e65b332a68353e902093bb15bf2cc6ced23..6a5fcf34323538f18c74b4a0c91d543127b21538 100644
--- a/cfrontend/Csyntax.v
+++ b/cfrontend/Csyntax.v
@@ -1,6 +1,7 @@
(** * Abstract syntax for the Clight language *)
Require Import Coqlib.
+Require Import Errors.
Require Import Integers.
Require Import Floats.
Require Import AST.
@@ -251,17 +252,19 @@ Qed.
(** Byte offset for a field in a struct. *)
+Open Local Scope string_scope.
+
Fixpoint field_offset_rec (id: ident) (fld: fieldlist) (pos: Z)
- {struct fld} : option Z :=
+ {struct fld} : res Z :=
match fld with
- | Fnil => None
+ | Fnil => Error (MSG "Unknown field " :: CTX id :: nil)
| Fcons id' t fld' =>
if ident_eq id id'
- then Some (align pos (alignof t))
+ then OK (align pos (alignof t))
else field_offset_rec id fld' (align pos (alignof t) + sizeof t)
end.
-Definition field_offset (id: ident) (fld: fieldlist) : option Z :=
+Definition field_offset (id: ident) (fld: fieldlist) : res Z :=
field_offset_rec id fld 0.
(* Describe how a variable of the given type must be accessed:
diff --git a/common/AST.v b/common/AST.v
index 5b8c997ab10f85e485fa30164a0c62034ca7841e..403861deba6635f961f6f8b9874e4f8df7d51176 100644
--- a/common/AST.v
+++ b/common/AST.v
@@ -2,11 +2,14 @@
the abstract syntax trees of many of the intermediate languages. *)
Require Import Coqlib.
+Require Import Errors.
Require Import Integers.
Require Import Floats.
Set Implicit Arguments.
+(** * Syntactic elements *)
+
(** Identifiers (names of local variables, of global symbols and functions,
etc) are represented by the type [positive] of positive integers. *)
@@ -14,8 +17,9 @@ Definition ident := positive.
Definition ident_eq := peq.
-(** The languages are weakly typed, using only two types: [Tint] for
- integers and pointers, and [Tfloat] for floating-point numbers. *)
+(** The intermediate languages are weakly typed, using only two types:
+ [Tint] for integers and pointers, and [Tfloat] for floating-point
+ numbers. *)
Inductive typ : Set :=
| Tint : typ
@@ -24,6 +28,9 @@ Inductive typ : Set :=
Definition typesize (ty: typ) : Z :=
match ty with Tint => 4 | Tfloat => 8 end.
+Lemma typesize_pos: forall ty, typesize ty > 0.
+Proof. destruct ty; simpl; omega. Qed.
+
(** Additionally, function definitions and function calls are annotated
by function signatures indicating the number and types of arguments,
as well as the type of the returned value if any. These signatures
@@ -82,6 +89,14 @@ Record program (F V: Set) : Set := mkprogram {
prog_vars: list (ident * list init_data * V)
}.
+Definition prog_funct_names (F V: Set) (p: program F V) : list ident :=
+ map (@fst ident F) p.(prog_funct).
+
+Definition prog_var_names (F V: Set) (p: program F V) : list ident :=
+ map (fun x: ident * list init_data * V => fst(fst x)) p.(prog_vars).
+
+(** * Generic transformations over programs *)
+
(** We now define a general iterator over programs that applies a given
code transformation function to all function descriptions and leaves
the other parts of the program unchanged. *)
@@ -117,48 +132,63 @@ End TRANSF_PROGRAM.
code transformation function can fail and therefore returns an
option type. *)
+Open Local Scope error_monad_scope.
+Open Local Scope string_scope.
+
Section MAP_PARTIAL.
Variable A B C: Set.
-Variable f: B -> option C.
+Variable prefix_errmsg: A -> errmsg.
+Variable f: B -> res C.
-Fixpoint map_partial (l: list (A * B)) : option (list (A * C)) :=
+Fixpoint map_partial (l: list (A * B)) : res (list (A * C)) :=
match l with
- | nil => Some nil
+ | nil => OK nil
| (a, b) :: rem =>
match f b with
- | None => None
- | Some c =>
- match map_partial rem with
- | None => None
- | Some res => Some ((a, c) :: res)
- end
+ | Error msg => Error (prefix_errmsg a ++ msg)%list
+ | OK c =>
+ do rem' <- map_partial rem;
+ OK ((a, c) :: rem')
end
end.
Remark In_map_partial:
forall l l' a c,
- map_partial l = Some l' ->
+ map_partial l = OK l' ->
In (a, c) l' ->
- exists b, In (a, b) l /\ f b = Some c.
+ exists b, In (a, b) l /\ f b = OK c.
Proof.
induction l; simpl.
- intros. inversion H; subst. elim H0.
- destruct a as [a1 b1]. intros until c.
+ intros. inv H. elim H0.
+ intros until c. destruct a as [a1 b1].
caseEq (f b1); try congruence.
- intros c1 EQ1. caseEq (map_partial l); try congruence.
- intros res EQ2 EQ3 IN. inversion EQ3; clear EQ3; subst l'.
- elim IN; intro. inversion H; subst.
- exists b1; auto.
+ intro c1; intros. monadInv H0.
+ elim H1; intro. inv H0. exists b1; auto.
exploit IHl; eauto. intros [b [P Q]]. exists b; auto.
Qed.
+Remark map_partial_forall2:
+ forall l l',
+ map_partial l = OK l' ->
+ list_forall2
+ (fun (a_b: A * B) (a_c: A * C) =>
+ fst a_b = fst a_c /\ f (snd a_b) = OK (snd a_c))
+ l l'.
+Proof.
+ induction l; simpl.
+ intros. inv H. constructor.
+ intro l'. destruct a as [a b].
+ caseEq (f b). 2: congruence. intro c; intros. monadInv H0.
+ constructor. simpl. auto. auto.
+Qed.
+
End MAP_PARTIAL.
Remark map_partial_total:
- forall (A B C: Set) (f: B -> C) (l: list (A * B)),
- map_partial (fun b => Some (f b)) l =
- Some (List.map (fun a_b => (fst a_b, f (snd a_b))) l).
+ forall (A B C: Set) (prefix: A -> errmsg) (f: B -> C) (l: list (A * B)),
+ map_partial prefix (fun b => OK (f b)) l =
+ OK (List.map (fun a_b => (fst a_b, f (snd a_b))) l).
Proof.
induction l; simpl.
auto.
@@ -166,8 +196,8 @@ Proof.
Qed.
Remark map_partial_identity:
- forall (A B: Set) (l: list (A * B)),
- map_partial (fun b => Some b) l = Some l.
+ forall (A B: Set) (prefix: A -> errmsg) (l: list (A * B)),
+ map_partial prefix (fun b => OK b) l = OK l.
Proof.
induction l; simpl.
auto.
@@ -177,39 +207,39 @@ Qed.
Section TRANSF_PARTIAL_PROGRAM.
Variable A B V: Set.
-Variable transf_partial: A -> option B.
+Variable transf_partial: A -> res B.
-Function transform_partial_program (p: program A V) : option (program B V) :=
- match map_partial transf_partial p.(prog_funct) with
- | None => None
- | Some fl => Some (mkprogram fl p.(prog_main) p.(prog_vars))
- end.
+Definition prefix_funct_name (id: ident) : errmsg :=
+ MSG "In function " :: CTX id :: MSG ":\n" :: nil.
+
+Definition transform_partial_program (p: program A V) : res (program B V) :=
+ do fl <- map_partial prefix_funct_name transf_partial p.(prog_funct);
+ OK (mkprogram fl p.(prog_main) p.(prog_vars)).
Lemma transform_partial_program_function:
forall p tp i tf,
- transform_partial_program p = Some tp ->
+ transform_partial_program p = OK tp ->
In (i, tf) tp.(prog_funct) ->
- exists f, In (i, f) p.(prog_funct) /\ transf_partial f = Some tf.
+ exists f, In (i, f) p.(prog_funct) /\ transf_partial f = OK tf.
Proof.
- intros. functional inversion H.
- apply In_map_partial with fl; auto.
- inversion H; subst tp; assumption.
+ intros. monadInv H. simpl in H0.
+ eapply In_map_partial; eauto.
Qed.
Lemma transform_partial_program_main:
forall p tp,
- transform_partial_program p = Some tp ->
+ transform_partial_program p = OK tp ->
tp.(prog_main) = p.(prog_main).
Proof.
- intros. functional inversion H. reflexivity.
+ intros. monadInv H. reflexivity.
Qed.
Lemma transform_partial_program_vars:
forall p tp,
- transform_partial_program p = Some tp ->
+ transform_partial_program p = OK tp ->
tp.(prog_vars) = p.(prog_vars).
Proof.
- intros. functional inversion H. reflexivity.
+ intros. monadInv H. reflexivity.
Qed.
End TRANSF_PARTIAL_PROGRAM.
@@ -221,49 +251,104 @@ End TRANSF_PARTIAL_PROGRAM.
Section TRANSF_PARTIAL_PROGRAM2.
Variable A B V W: Set.
-Variable transf_partial_function: A -> option B.
-Variable transf_partial_variable: V -> option W.
-
-Function transform_partial_program2 (p: program A V) : option (program B W) :=
- match map_partial transf_partial_function p.(prog_funct) with
- | None => None
- | Some fl =>
- match map_partial transf_partial_variable p.(prog_vars) with
- | None => None
- | Some vl => Some (mkprogram fl p.(prog_main) vl)
- end
- end.
+Variable transf_partial_function: A -> res B.
+Variable transf_partial_variable: V -> res W.
+
+Definition prefix_var_name (id_init: ident * list init_data) : errmsg :=
+ MSG "In global variable " :: CTX (fst id_init) :: MSG ":\n" :: nil.
+
+Definition transform_partial_program2 (p: program A V) : res (program B W) :=
+ do fl <- map_partial prefix_funct_name transf_partial_function p.(prog_funct);
+ do vl <- map_partial prefix_var_name transf_partial_variable p.(prog_vars);
+ OK (mkprogram fl p.(prog_main) vl).
Lemma transform_partial_program2_function:
forall p tp i tf,
- transform_partial_program2 p = Some tp ->
+ transform_partial_program2 p = OK tp ->
In (i, tf) tp.(prog_funct) ->
- exists f, In (i, f) p.(prog_funct) /\ transf_partial_function f = Some tf.
+ exists f, In (i, f) p.(prog_funct) /\ transf_partial_function f = OK tf.
Proof.
- intros. functional inversion H.
- apply In_map_partial with fl. auto. subst tp; assumption.
+ intros. monadInv H.
+ eapply In_map_partial; eauto.
Qed.
Lemma transform_partial_program2_variable:
forall p tp i tv,
- transform_partial_program2 p = Some tp ->
+ transform_partial_program2 p = OK tp ->
In (i, tv) tp.(prog_vars) ->
- exists v, In (i, v) p.(prog_vars) /\ transf_partial_variable v = Some tv.
+ exists v, In (i, v) p.(prog_vars) /\ transf_partial_variable v = OK tv.
Proof.
- intros. functional inversion H.
- apply In_map_partial with vl. auto. subst tp; assumption.
+ intros. monadInv H.
+ eapply In_map_partial; eauto.
Qed.
Lemma transform_partial_program2_main:
forall p tp,
- transform_partial_program2 p = Some tp ->
+ transform_partial_program2 p = OK tp ->
tp.(prog_main) = p.(prog_main).
Proof.
- intros. functional inversion H. reflexivity.
+ intros. monadInv H. reflexivity.
Qed.
End TRANSF_PARTIAL_PROGRAM2.
+(** The following is a relational presentation of
+ [transform_program_partial2]. Given relations between function
+ definitions and between variable information, it defines a relation
+ between programs stating that the two programs have the same shape
+ (same global names, etc) and that identically-named function definitions
+ are variable information are related. *)
+
+Section MATCH_PROGRAM.
+
+Variable A B V W: Set.
+Variable match_fundef: A -> B -> Prop.
+Variable match_varinfo: V -> W -> Prop.
+
+Definition match_funct_entry (x1: ident * A) (x2: ident * B) :=
+ match x1, x2 with
+ | (id1, fn1), (id2, fn2) => id1 = id2 /\ match_fundef fn1 fn2
+ end.
+
+Definition match_var_entry (x1: ident * list init_data * V) (x2: ident * list init_data * W) :=
+ match x1, x2 with
+ | (id1, init1, info1), (id2, init2, info2) => id1 = id2 /\ init1 = init2 /\ match_varinfo info1 info2
+ end.
+
+Definition match_program (p1: program A V) (p2: program B W) : Prop :=
+ list_forall2 match_funct_entry p1.(prog_funct) p2.(prog_funct)
+ /\ p1.(prog_main) = p2.(prog_main)
+ /\ list_forall2 match_var_entry p1.(prog_vars) p2.(prog_vars).
+
+End MATCH_PROGRAM.
+
+Remark transform_partial_program2_match:
+ forall (A B V W: Set)
+ (transf_partial_function: A -> res B)
+ (transf_partial_variable: V -> res W)
+ (p: program A V) (tp: program B W),
+ transform_partial_program2 transf_partial_function transf_partial_variable p = OK tp ->
+ match_program
+ (fun fd tfd => transf_partial_function fd = OK tfd)
+ (fun info tinfo => transf_partial_variable info = OK tinfo)
+ p tp.
+Proof.
+ intros. monadInv H. split.
+ apply list_forall2_imply with
+ (fun (ab: ident * A) (ac: ident * B) =>
+ fst ab = fst ac /\ transf_partial_function (snd ab) = OK (snd ac)).
+ eapply map_partial_forall2. eauto.
+ intros. destruct v1; destruct v2; simpl in *. auto.
+ split. auto.
+ apply list_forall2_imply with
+ (fun (ab: ident * list init_data * V) (ac: ident * list init_data * W) =>
+ fst ab = fst ac /\ transf_partial_variable (snd ab) = OK (snd ac)).
+ eapply map_partial_forall2. eauto.
+ intros. destruct v1; destruct v2; simpl in *. destruct p0; destruct p1. intuition congruence.
+Qed.
+
+(** * External functions *)
+
(** For most languages, the functions composing the program are either
internal functions, defined within the language, or external functions
(a.k.a. system calls) that emit an event when applied. We define
@@ -296,16 +381,12 @@ End TRANSF_FUNDEF.
Section TRANSF_PARTIAL_FUNDEF.
Variable A B: Set.
-Variable transf_partial: A -> option B.
+Variable transf_partial: A -> res B.
-Definition transf_partial_fundef (fd: fundef A): option (fundef B) :=
+Definition transf_partial_fundef (fd: fundef A): res (fundef B) :=
match fd with
- | Internal f =>
- match transf_partial f with
- | None => None
- | Some f' => Some (Internal f')
- end
- | External ef => Some (External ef)
+ | Internal f => do f' <- transf_partial f; OK (Internal f')
+ | External ef => OK (External ef)
end.
End TRANSF_PARTIAL_FUNDEF.
diff --git a/common/Errors.v b/common/Errors.v
new file mode 100644
index 0000000000000000000000000000000000000000..2c1d752aecb8c38fbabf5f6c82c1baa4b089d023
--- /dev/null
+++ b/common/Errors.v
@@ -0,0 +1,167 @@
+(** Error reporting and the error monad. *)
+
+Require Import String.
+Require Import Coqlib.
+
+Close Scope string_scope.
+
+Set Implicit Arguments.
+
+(** * Representation of error messages. *)
+
+(** Compile-time errors produce an error message, represented in Coq
+ as a list of either substrings or positive numbers encoding
+ a source-level identifier (see module AST). *)
+
+Inductive errcode: Set :=
+ | MSG: string -> errcode
+ | CTX: positive -> errcode.
+
+Definition errmsg: Set := list errcode.
+
+Definition msg (s: string) : errmsg := MSG s :: nil.
+
+(** * The error monad *)
+
+(** Compilation functions that can fail have return type [res A].
+ The return value is either [OK res] to indicate success,
+ or [Error msg] to indicate failure. *)
+
+Inductive res (A: Set) : Set :=
+| OK: A -> res A
+| Error: errmsg -> res A.
+
+Implicit Arguments Error [A].
+
+(** To automate the propagation of errors, we use a monadic style
+ with the following [bind] operation. *)
+
+Definition bind (A B: Set) (f: res A) (g: A -> res B) : res B :=
+ match f with
+ | OK x => g x
+ | Error msg => Error msg
+ end.
+
+Definition bind2 (A B C: Set) (f: res (A * B)) (g: A -> B -> res C) : res C :=
+ match f with
+ | OK (x, y) => g x y
+ | Error msg => Error msg
+ end.
+
+(** The [do] notation, inspired by Haskell's, keeps the code readable. *)
+
+Notation "'do' X <- A ; B" := (bind A (fun X => B))
+ (at level 200, X ident, A at level 100, B at level 200)
+ : error_monad_scope.
+
+Notation "'do' ( X , Y ) <- A ; B" := (bind2 A (fun X Y => B))
+ (at level 200, X ident, Y ident, A at level 100, B at level 200)
+ : error_monad_scope.
+
+Remark bind_inversion:
+ forall (A B: Set) (f: res A) (g: A -> res B) (y: B),
+ bind f g = OK y ->
+ exists x, f = OK x /\ g x = OK y.
+Proof.
+ intros until y. destruct f; simpl; intros.
+ exists a; auto.
+ discriminate.
+Qed.
+
+Remark bind2_inversion:
+ forall (A B C: Set) (f: res (A*B)) (g: A -> B -> res C) (z: C),
+ bind2 f g = OK z ->
+ exists x, exists y, f = OK (x, y) /\ g x y = OK z.
+Proof.
+ intros until z. destruct f; simpl.
+ destruct p; simpl; intros. exists a; exists b; auto.
+ intros; discriminate.
+Qed.
+
+Open Local Scope error_monad_scope.
+
+(** This is the familiar monadic map iterator. *)
+
+Fixpoint mmap (A B: Set) (f: A -> res B) (l: list A) {struct l} : res (list B) :=
+ match l with
+ | nil => OK nil
+ | hd :: tl => do hd' <- f hd; do tl' <- mmap f tl; OK (hd' :: tl')
+ end.
+
+Remark mmap_inversion:
+ forall (A B: Set) (f: A -> res B) (l: list A) (l': list B),
+ mmap f l = OK l' ->
+ list_forall2 (fun x y => f x = OK y) l l'.
+Proof.
+ induction l; simpl; intros.
+ inversion_clear H. constructor.
+ destruct (bind_inversion _ _ H) as [hd' [P Q]].
+ destruct (bind_inversion _ _ Q) as [tl' [R S]].
+ inversion_clear S.
+ constructor. auto. auto.
+Qed.
+
+(** * Reasoning over monadic computations *)
+
+(** The [monadInv H] tactic below simplifies hypotheses of the form
+<<
+ H: (do x <- a; b) = OK res
+>>
+ By definition of the bind operation, both computations [a] and
+ [b] must succeed for their composition to succeed. The tactic
+ therefore generates the following hypotheses:
+
+ x: ...
+ H1: a = OK x
+ H2: b x = OK res
+*)
+
+Ltac monadInv1 H :=
+ match type of H with
+ | (OK _ = OK _) =>
+ inversion H; clear H; try subst
+ | (Error _ = OK _) =>
+ discriminate
+ | (bind ?F ?G = OK ?X) =>
+ let x := fresh "x" in (
+ let EQ1 := fresh "EQ" in (
+ let EQ2 := fresh "EQ" in (
+ destruct (bind_inversion F G H) as [x [EQ1 EQ2]];
+ clear H;
+ try (monadInv1 EQ2))))
+ | (bind2 ?F ?G = OK ?X) =>
+ let x1 := fresh "x" in (
+ let x2 := fresh "x" in (
+ let EQ1 := fresh "EQ" in (
+ let EQ2 := fresh "EQ" in (
+ destruct (bind2_inversion F G H) as [x1 [x2 [EQ1 EQ2]]];
+ clear H;
+ try (monadInv1 EQ2)))))
+ | (mmap ?F ?L = OK ?M) =>
+ generalize (mmap_inversion F L H); intro
+ end.
+
+Ltac monadInv H :=
+ match type of H with
+ | (OK _ = OK _) => monadInv1 H
+ | (Error _ = OK _) => monadInv1 H
+ | (bind ?F ?G = OK ?X) => monadInv1 H
+ | (bind2 ?F ?G = OK ?X) => monadInv1 H
+ | (?F _ _ _ _ _ _ _ _ = OK _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ _ _ _ _ = OK _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ _ _ _ = OK _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ _ _ = OK _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ _ = OK _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ _ = OK _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ _ = OK _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ | (?F _ = OK _) =>
+ ((progress simpl in H) || unfold F in H); monadInv1 H
+ end.
+
diff --git a/common/Events.v b/common/Events.v
index a0559fd0684845d16afe5667fac8f7660840f5e0..e1a4729a1ef105130749af5fd845726f76ac4d24 100644
--- a/common/Events.v
+++ b/common/Events.v
@@ -1,4 +1,4 @@
-(** Representation of (traces of) observable events. *)
+(** Representation of observable events and execution traces. *)
Require Import Coqlib.
Require Import AST.
@@ -6,23 +6,77 @@ Require Import Integers.
Require Import Floats.
Require Import Values.
+(** The observable behaviour of programs is stated in terms of
+ input/output events, which can also be thought of as system calls
+ to the operating system. An event is generated each time an
+ external function (see module AST) is invoked. The event records
+ the name of the external function, the arguments to the function
+ invocation provided by the program, and the return value provided by
+ the outside world (e.g. the operating system). Arguments and values
+ are either integers or floating-point numbers. We currently do not
+ allow pointers to be exchanged between the program and the outside
+ world. *)
+
Inductive eventval: Set :=
| EVint: int -> eventval
| EVfloat: float -> eventval.
-Parameter trace: Set.
-Parameter E0: trace.
-Parameter Eextcall: ident -> list eventval -> eventval -> trace.
-Parameter Eapp: trace -> trace -> trace.
+Record event : Set := mkevent {
+ ev_name: ident;
+ ev_args: list eventval;
+ ev_res: eventval
+}.
+
+(** The dynamic semantics for programs collect traces of events.
+ Traces are of two kinds: finite (type [trace])
+ or infinite (type [traceinf]). *)
+
+Definition trace := list event.
+
+Definition E0 : trace := nil.
+
+Definition Eextcall
+ (name: ident) (args: list eventval) (res: eventval) : trace :=
+ mkevent name args res :: nil.
+
+Definition Eapp (t1 t2: trace) : trace := t1 ++ t2.
+
+CoInductive traceinf : Set :=
+ | Econsinf: event -> traceinf -> traceinf.
+
+Fixpoint Eappinf (t: trace) (T: traceinf) {struct t} : traceinf :=
+ match t with
+ | nil => T
+ | ev :: t' => Econsinf ev (Eappinf t' T)
+ end.
+
+(** Concatenation of traces is written [**] in the finite case
+ or [***] in the infinite case. *)
Infix "**" := Eapp (at level 60, right associativity).
+Infix "***" := Eappinf (at level 60, right associativity).
-Axiom E0_left: forall t, E0 ** t = t.
-Axiom E0_right: forall t, t ** E0 = t.
-Axiom Eapp_assoc: forall t1 t2 t3, (t1 ** t2) ** t3 = t1 ** (t2 ** t3).
+Lemma E0_left: forall t, E0 ** t = t.
+Proof. auto. Qed.
+
+Lemma E0_right: forall t, t ** E0 = t.
+Proof. intros. unfold E0, Eapp. rewrite <- app_nil_end. auto. Qed.
+
+Lemma Eapp_assoc: forall t1 t2 t3, (t1 ** t2) ** t3 = t1 ** (t2 ** t3).
+Proof. intros. unfold Eapp, trace. apply app_ass. Qed.
+
+Lemma Eappinf_assoc: forall t1 t2 T, (t1 ** t2) *** T = t1 *** (t2 *** T).
+Proof.
+ induction t1; intros; simpl. auto. decEq; auto.
+Qed.
Hint Rewrite E0_left E0_right Eapp_assoc: trace_rewrite.
+Opaque trace E0 Eextcall Eapp.
+
+(** The following [traceEq] tactic proves equalities between traces
+ or infinite traces. *)
+
Ltac substTraceHyp :=
match goal with
| [ H: (@eq trace ?x ?y) |- _ ] =>
@@ -40,6 +94,11 @@ Ltac decomposeTraceEq :=
Ltac traceEq :=
repeat substTraceHyp; autorewrite with trace_rewrite; decomposeTraceEq.
+(** The predicate [event_match ef vargs t vres] expresses that
+ the event [t] is generated when invoking external function [ef]
+ with arguments [vargs], and obtaining [vres] as a return value
+ from the operating system. *)
+
Inductive eventval_match: eventval -> typ -> val -> Prop :=
| ev_match_int:
forall i, eventval_match (EVint i) Tint (Vint i)
@@ -63,6 +122,10 @@ Inductive event_match:
eventval_match eres (proj_sig_res ef.(ef_sig)) vres ->
event_match ef vargs (Eextcall ef.(ef_id) eargs eres) vres.
+(** The following section shows that [event_match] is stable under
+ relocation of pointer values, as performed by memory injections
+ (see module [Mem]). *)
+
Require Import Mem.
Section EVENT_MATCH_INJECT.
@@ -101,3 +164,41 @@ Proof.
Qed.
End EVENT_MATCH_INJECT.
+
+(** The following section shows that [event_match] is stable under
+ replacement of [Vundef] values by more defined values. *)
+
+Section EVENT_MATCH_LESSDEF.
+
+Remark eventval_match_lessdef:
+ forall ev ty v1, eventval_match ev ty v1 ->
+ forall v2, Val.lessdef v1 v2 ->
+ eventval_match ev ty v2.
+Proof.
+ induction 1; intros; inv H; constructor.
+Qed.
+
+Remark eventval_list_match_moredef:
+ forall evl tyl vl1, eventval_list_match evl tyl vl1 ->
+ forall vl2, Val.lessdef_list vl1 vl2 ->
+ eventval_list_match evl tyl vl2.
+Proof.
+ induction 1; intros.
+ inversion H; constructor.
+ inversion H1; constructor.
+ eapply eventval_match_lessdef; eauto.
+ eauto.
+Qed.
+
+Lemma event_match_lessdef:
+ forall ef args1 t res1 args2,
+ event_match ef args1 t res1 ->
+ Val.lessdef_list args1 args2 ->
+ exists res2, event_match ef args2 t res2 /\ Val.lessdef res1 res2.
+Proof.
+ intros. inversion H; subst. exists res1; split.
+ constructor. eapply eventval_list_match_moredef; eauto. auto.
+ auto.
+Qed.
+
+End EVENT_MATCH_LESSDEF.
diff --git a/common/Globalenvs.v b/common/Globalenvs.v
index ccb7b03e3c0263add929b35f0dc2edda74f330a0..623200fe380e0940e43c1fb4175e773d3ccfd093 100644
--- a/common/Globalenvs.v
+++ b/common/Globalenvs.v
@@ -19,6 +19,7 @@
system. *)
Require Import Coqlib.
+Require Import Errors.
Require Import Maps.
Require Import AST.
Require Import Integers.
@@ -60,6 +61,34 @@ Module Type GENV.
Hypothesis find_funct_find_funct_ptr:
forall (F: Set) (ge: t F) (b: block),
find_funct ge (Vptr b Int.zero) = find_funct_ptr ge b.
+
+ Hypothesis find_symbol_exists:
+ forall (F V: Set) (p: program F V)
+ (id: ident) (init: list init_data) (v: V),
+ In (id, init, v) (prog_vars p) ->
+ exists b, find_symbol (globalenv p) id = Some b.
+ Hypothesis find_funct_ptr_exists:
+ forall (F V: Set) (p: program F V) (id: ident) (f: F),
+ list_norepet (prog_funct_names p) ->
+ list_disjoint (prog_funct_names p) (prog_var_names p) ->
+ In (id, f) (prog_funct p) ->
+ exists b, find_symbol (globalenv p) id = Some b
+ /\ find_funct_ptr (globalenv p) b = Some f.
+
+ Hypothesis find_funct_ptr_inversion:
+ forall (F V: Set) (P: F -> Prop) (p: program F V) (b: block) (f: F),
+ find_funct_ptr (globalenv p) b = Some f ->
+ exists id, In (id, f) (prog_funct p).
+ Hypothesis find_funct_inversion:
+ forall (F V: Set) (P: F -> Prop) (p: program F V) (v: val) (f: F),
+ find_funct (globalenv p) v = Some f ->
+ exists id, In (id, f) (prog_funct p).
+ Hypothesis find_funct_ptr_symbol_inversion:
+ forall (F V: Set) (p: program F V) (id: ident) (b: block) (f: F),
+ find_symbol (globalenv p) id = Some b ->
+ find_funct_ptr (globalenv p) b = Some f ->
+ In (id, f) p.(prog_funct).
+
Hypothesis find_funct_ptr_prop:
forall (F V: Set) (P: F -> Prop) (p: program F V) (b: block) (f: F),
(forall id f, In (id, f) (prog_funct p) -> P f) ->
@@ -70,24 +99,19 @@ Module Type GENV.
(forall id f, In (id, f) (prog_funct p) -> P f) ->
find_funct (globalenv p) v = Some f ->
P f.
- Hypothesis find_funct_ptr_symbol_inversion:
- forall (F V: Set) (p: program F V) (id: ident) (b: block) (f: F),
- find_symbol (globalenv p) id = Some b ->
- find_funct_ptr (globalenv p) b = Some f ->
- In (id, f) p.(prog_funct).
Hypothesis initmem_nullptr:
forall (F V: Set) (p: program F V),
let m := init_mem p in
valid_block m nullptr /\
m.(blocks) nullptr = empty_block 0 0.
- Hypothesis initmem_block_init:
- forall (F V: Set) (p: program F V) (b: block),
- exists id, (init_mem p).(blocks) b = block_init_data id.
- Hypothesis find_funct_ptr_inv:
+ Hypothesis initmem_inject_neutral:
+ forall (F V: Set) (p: program F V),
+ mem_inject_neutral (init_mem p).
+ Hypothesis find_funct_ptr_negative:
forall (F V: Set) (p: program F V) (b: block) (f: F),
find_funct_ptr (globalenv p) b = Some f -> b < 0.
- Hypothesis find_symbol_inv:
+ Hypothesis find_symbol_not_fresh:
forall (F V: Set) (p: program F V) (id: ident) (b: block),
find_symbol (globalenv p) id = Some b -> b < nextblock (init_mem p).
@@ -95,74 +119,162 @@ Module Type GENV.
and operations over global environments. *)
Hypothesis find_funct_ptr_transf:
- forall (A B V: Set) (transf: A -> B) (p: program A V) (b: block) (f: A),
+ forall (A B V: Set) (transf: A -> B) (p: program A V),
+ forall (b: block) (f: A),
find_funct_ptr (globalenv p) b = Some f ->
find_funct_ptr (globalenv (transform_program transf p)) b = Some (transf f).
Hypothesis find_funct_transf:
- forall (A B V: Set) (transf: A -> B) (p: program A V) (v: val) (f: A),
+ forall (A B V: Set) (transf: A -> B) (p: program A V),
+ forall (v: val) (f: A),
find_funct (globalenv p) v = Some f ->
find_funct (globalenv (transform_program transf p)) v = Some (transf f).
Hypothesis find_symbol_transf:
- forall (A B V: Set) (transf: A -> B) (p: program A V) (s: ident),
+ forall (A B V: Set) (transf: A -> B) (p: program A V),
+ forall (s: ident),
find_symbol (globalenv (transform_program transf p)) s =
find_symbol (globalenv p) s.
Hypothesis init_mem_transf:
forall (A B V: Set) (transf: A -> B) (p: program A V),
init_mem (transform_program transf p) = init_mem p.
+ Hypothesis find_funct_ptr_rev_transf:
+ forall (A B V: Set) (transf: A -> B) (p: program A V),
+ forall (b : block) (tf : B),
+ find_funct_ptr (globalenv (transform_program transf p)) b = Some tf ->
+ exists f : A, find_funct_ptr (globalenv p) b = Some f /\ transf f = tf.
+ Hypothesis find_funct_rev_transf:
+ forall (A B V: Set) (transf: A -> B) (p: program A V),
+ forall (v : val) (tf : B),
+ find_funct (globalenv (transform_program transf p)) v = Some tf ->
+ exists f : A, find_funct (globalenv p) v = Some f /\ transf f = tf.
(** Commutation properties between partial program transformations
and operations over global environments. *)
Hypothesis find_funct_ptr_transf_partial:
- forall (A B V: Set) (transf: A -> option B)
- (p: program A V) (p': program B V),
- transform_partial_program transf p = Some p' ->
+ forall (A B V: Set) (transf: A -> res B) (p: program A V) (p': program B V),
+ transform_partial_program transf p = OK p' ->
forall (b: block) (f: A),
find_funct_ptr (globalenv p) b = Some f ->
- find_funct_ptr (globalenv p') b = transf f /\ transf f <> None.
+ exists f',
+ find_funct_ptr (globalenv p') b = Some f' /\ transf f = OK f'.
Hypothesis find_funct_transf_partial:
- forall (A B V: Set) (transf: A -> option B)
- (p: program A V) (p': program B V),
- transform_partial_program transf p = Some p' ->
+ forall (A B V: Set) (transf: A -> res B) (p: program A V) (p': program B V),
+ transform_partial_program transf p = OK p' ->
forall (v: val) (f: A),
find_funct (globalenv p) v = Some f ->
- find_funct (globalenv p') v = transf f /\ transf f <> None.
+ exists f',
+ find_funct (globalenv p') v = Some f' /\ transf f = OK f'.
Hypothesis find_symbol_transf_partial:
- forall (A B V: Set) (transf: A -> option B)
- (p: program A V) (p': program B V),
- transform_partial_program transf p = Some p' ->
+ forall (A B V: Set) (transf: A -> res B) (p: program A V) (p': program B V),
+ transform_partial_program transf p = OK p' ->
forall (s: ident),
find_symbol (globalenv p') s = find_symbol (globalenv p) s.
Hypothesis init_mem_transf_partial:
- forall (A B V: Set) (transf: A -> option B)
- (p: program A V) (p': program B V),
- transform_partial_program transf p = Some p' ->
+ forall (A B V: Set) (transf: A -> res B) (p: program A V) (p': program B V),
+ transform_partial_program transf p = OK p' ->
init_mem p' = init_mem p.
+ Hypothesis find_funct_ptr_rev_transf_partial:
+ forall (A B V: Set) (transf: A -> res B) (p: program A V) (p': program B V),
+ transform_partial_program transf p = OK p' ->
+ forall (b : block) (tf : B),
+ find_funct_ptr (globalenv p') b = Some tf ->
+ exists f : A,
+ find_funct_ptr (globalenv p) b = Some f /\ transf f = OK tf.
+ Hypothesis find_funct_rev_transf_partial:
+ forall (A B V: Set) (transf: A -> res B) (p: program A V) (p': program B V),
+ transform_partial_program transf p = OK p' ->
+ forall (v : val) (tf : B),
+ find_funct (globalenv p') v = Some tf ->
+ exists f : A,
+ find_funct (globalenv p) v = Some f /\ transf f = OK tf.
Hypothesis find_funct_ptr_transf_partial2:
- forall (A B V W: Set) (transf_fun: A -> option B) (transf_var: V -> option W)
+ forall (A B V W: Set) (transf_fun: A -> res B) (transf_var: V -> res W)
(p: program A V) (p': program B W),
- transform_partial_program2 transf_fun transf_var p = Some p' ->
+ transform_partial_program2 transf_fun transf_var p = OK p' ->
forall (b: block) (f: A),
find_funct_ptr (globalenv p) b = Some f ->
- find_funct_ptr (globalenv p') b = transf_fun f /\ transf_fun f <> None.
+ exists f',
+ find_funct_ptr (globalenv p') b = Some f' /\ transf_fun f = OK f'.
Hypothesis find_funct_transf_partial2:
- forall (A B V W: Set) (transf_fun: A -> option B) (transf_var: V -> option W)
+ forall (A B V W: Set) (transf_fun: A -> res B) (transf_var: V -> res W)
(p: program A V) (p': program B W),
- transform_partial_program2 transf_fun transf_var p = Some p' ->
+ transform_partial_program2 transf_fun transf_var p = OK p' ->
forall (v: val) (f: A),
find_funct (globalenv p) v = Some f ->
- find_funct (globalenv p') v = transf_fun f /\ transf_fun f <> None.
+ exists f',
+ find_funct (globalenv p') v = Some f' /\ transf_fun f = OK f'.
Hypothesis find_symbol_transf_partial2:
- forall (A B V W: Set) (transf_fun: A -> option B) (transf_var: V -> option W)
+ forall (A B V W: Set) (transf_fun: A -> res B) (transf_var: V -> res W)
(p: program A V) (p': program B W),
- transform_partial_program2 transf_fun transf_var p = Some p' ->
+ transform_partial_program2 transf_fun transf_var p = OK p' ->
forall (s: ident),
find_symbol (globalenv p') s = find_symbol (globalenv p) s.
Hypothesis init_mem_transf_partial2:
- forall (A B V W: Set) (transf_fun: A -> option B) (transf_var: V -> option W)
+ forall (A B V W: Set) (transf_fun: A -> res B) (transf_var: V -> res W)
+ (p: program A V) (p': program B W),
+ transform_partial_program2 transf_fun transf_var p = OK p' ->
+ init_mem p' = init_mem p.
+ Hypothesis find_funct_ptr_rev_transf_partial2:
+ forall (A B V W: Set) (transf_fun: A -> res B) (transf_var: V -> res W)
+ (p: program A V) (p': program B W),
+ transform_partial_program2 transf_fun transf_var p = OK p' ->
+ forall (b : block) (tf : B),
+ find_funct_ptr (globalenv p') b = Some tf ->
+ exists f : A,
+ find_funct_ptr (globalenv p) b = Some f /\ transf_fun f = OK tf.
+ Hypothesis find_funct_rev_transf_partial2:
+ forall (A B V W: Set) (transf_fun: A -> res B) (transf_var: V -> res W)
(p: program A V) (p': program B W),
- transform_partial_program2 transf_fun transf_var p = Some p' ->
+ transform_partial_program2 transf_fun transf_var p = OK p' ->
+ forall (v : val) (tf : B),
+ find_funct (globalenv p') v = Some tf ->
+ exists f : A,
+ find_funct (globalenv p) v = Some f /\ transf_fun f = OK tf.
+
+(** Commutation properties between matching between programs
+ and operations over global environments. *)
+
+ Hypothesis find_funct_ptr_match:
+ forall (A B V W: Set) (match_fun: A -> B -> Prop)
+ (match_var: V -> W -> Prop) (p: program A V) (p': program B W),
+ match_program match_fun match_var p p' ->
+ forall (b : block) (f : A),
+ find_funct_ptr (globalenv p) b = Some f ->
+ exists tf : B,
+ find_funct_ptr (globalenv p') b = Some tf /\ match_fun f tf.
+ Hypothesis find_funct_ptr_rev_match:
+ forall (A B V W: Set) (match_fun: A -> B -> Prop)
+ (match_var: V -> W -> Prop) (p: program A V) (p': program B W),
+ match_program match_fun match_var p p' ->
+ forall (b : block) (tf : B),
+ find_funct_ptr (globalenv p') b = Some tf ->
+ exists f : A,
+ find_funct_ptr (globalenv p) b = Some f /\ match_fun f tf.
+ Hypothesis find_funct_match:
+ forall (A B V W: Set) (match_fun: A -> B -> Prop)
+ (match_var: V -> W -> Prop) (p: program A V) (p': program B W),
+ match_program match_fun match_var p p' ->
+ forall (v : val) (f : A),
+ find_funct (globalenv p) v = Some f ->
+ exists tf : B, find_funct (globalenv p') v = Some tf /\ match_fun f tf.
+ Hypothesis find_funct_rev_match:
+ forall (A B V W: Set) (match_fun: A -> B -> Prop)
+ (match_var: V -> W -> Prop) (p: program A V) (p': program B W),
+ match_program match_fun match_var p p' ->
+ forall (v : val) (tf : B),
+ find_funct (globalenv p') v = Some tf ->
+ exists f : A, find_funct (globalenv p) v = Some f /\ match_fun f tf.
+ Hypothesis find_symbol_match:
+ forall (A B V W: Set) (match_fun: A -> B -> Prop)
+ (match_var: V -> W -> Prop) (p: program A V) (p': program B W),
+ match_program match_fun match_var p p' ->
+ forall (s : ident),
+ find_symbol (globalenv p') s = find_symbol (globalenv p) s.
+ Hypothesis init_mem_match:
+ forall (A B V W: Set) (match_fun: A -> B -> Prop)
+ (match_var: V -> W -> Prop) (p: program A V) (p': program B W),
+ match_program match_fun match_var p p' ->
init_mem p' = init_mem p.
End GENV.
@@ -280,10 +392,10 @@ Lemma initmem_nullptr:
forall (p: program F V),
let m := init_mem p in
valid_block m nullptr /\
- m.(blocks) nullptr = mkblock 0 0 (fun y => Undef) (undef_undef_outside 0 0).
+ m.(blocks) nullptr = mkblock 0 0 (fun y => Undef).
Proof.
pose (P := fun m => valid_block m nullptr /\
- m.(blocks) nullptr = mkblock 0 0 (fun y => Undef) (undef_undef_outside 0 0)).
+ m.(blocks) nullptr = mkblock 0 0 (fun y => Undef)).
assert (forall init, P (snd init) -> forall vars, P (snd (add_globals init vars))).
induction vars; simpl; intros.
auto.
@@ -297,25 +409,25 @@ Proof.
red; simpl. split. compute. auto. reflexivity.
Qed.
-Lemma initmem_block_init:
- forall (p: program F V) (b: block),
- exists id, (init_mem p).(blocks) b = block_init_data id.
+Lemma initmem_inject_neutral:
+ forall (p: program F V),
+ mem_inject_neutral (init_mem p).
Proof.
- assert (forall g0 vars g1 m b,
+ assert (forall g0 vars g1 m,
add_globals (g0, Mem.empty) vars = (g1, m) ->
- exists id, m.(blocks) b = block_init_data id).
- induction vars; simpl.
- intros. inversion H. unfold Mem.empty; simpl.
- exists (@nil init_data). symmetry. apply Mem.block_init_data_empty.
+ mem_inject_neutral m).
+ Opaque alloc_init_data.
+ induction vars; simpl.
+ intros. inv H. red; intros. destruct (load_inv _ _ _ _ _ H).
+ simpl in H1. rewrite Mem.getN_init in H1.
+ replace v with Vundef. auto. destruct chunk; simpl in H1; auto.
destruct a as [[id1 init1] info1].
- caseEq (add_globals (g0, Mem.empty) vars). intros g1 m1 EQ.
- intros g m b EQ1. injection EQ1; intros EQ2 EQ3; clear EQ1.
- rewrite <- EQ2; simpl. unfold update.
- case (zeq b (nextblock m1)); intro.
- exists init1; auto.
- eauto.
- intros. caseEq (globalenv_initmem p).
- intros g m EQ. unfold init_mem; rewrite EQ; simpl.
+ caseEq (add_globals (g0, Mem.empty) vars). intros g1 m1 EQ.
+ caseEq (alloc_init_data m1 init1). intros m2 b ALLOC.
+ intros. inv H.
+ eapply Mem.alloc_init_data_neutral; eauto.
+ intros. caseEq (globalenv_initmem p). intros g m EQ.
+ unfold init_mem; rewrite EQ; simpl.
unfold globalenv_initmem in EQ. eauto.
Qed.
@@ -325,7 +437,7 @@ Proof.
induction fns; simpl; intros. omega. unfold Zpred. omega.
Qed.
-Theorem find_funct_ptr_inv:
+Theorem find_funct_ptr_negative:
forall (p: program F V) (b: block) (f: F),
find_funct_ptr (globalenv p) b = Some f -> b < 0.
Proof.
@@ -340,7 +452,7 @@ Proof.
intros. eauto.
Qed.
-Theorem find_symbol_inv:
+Theorem find_symbol_not_fresh:
forall (p: program F V) (id: ident) (b: block),
find_symbol (globalenv p) id = Some b -> b < nextblock (init_mem p).
Proof.
@@ -358,6 +470,7 @@ Proof.
induction vars; simpl; intros until b.
intros. inversion H0. subst g m. simpl.
generalize (H fns s b H1). omega.
+ Transparent alloc_init_data.
destruct a as [[id1 init1] info1].
caseEq (add_globals (add_functs empty fns, Mem.empty) vars).
intros g1 m1 ADG EQ. inversion EQ; subst g m; clear EQ.
@@ -373,20 +486,125 @@ Qed.
End GENV.
(* Invariants on functions *)
+
+Lemma find_symbol_exists:
+ forall (F V: Set) (p: program F V)
+ (id: ident) (init: list init_data) (v: V),
+ In (id, init, v) (prog_vars p) ->
+ exists b, find_symbol (globalenv p) id = Some b.
+Proof.
+ intros until v.
+ assert (forall initm vl, In (id, init, v) vl ->
+ exists b, PTree.get id (@symbols F (fst (add_globals initm vl))) = Some b).
+ induction vl; simpl; intros.
+ elim H.
+ destruct a as [[id0 init0] v0].
+ caseEq (add_globals initm vl). intros g1 m1 EQ. simpl.
+ rewrite PTree.gsspec. destruct (peq id id0). econstructor; eauto.
+ elim H; intro. congruence. generalize (IHvl H0). rewrite EQ. auto.
+ intros. unfold globalenv, find_symbol, globalenv_initmem. auto.
+Qed.
+
+Remark find_symbol_above_nextfunction:
+ forall (F: Set) (id: ident) (b: block) (fns: list (ident * F)),
+ let g := add_functs (empty F) fns in
+ PTree.get id g.(symbols) = Some b ->
+ b > g.(nextfunction).
+Proof.
+ induction fns; simpl.
+ rewrite PTree.gempty. congruence.
+ rewrite PTree.gsspec. case (peq id (fst a)); intro.
+ intro EQ. inversion EQ. unfold Zpred. omega.
+ intros. generalize (IHfns H). unfold Zpred; omega.
+Qed.
+
+Remark find_symbol_add_globals:
+ forall (F V: Set) (id: ident) (ge_m: t F * mem) (vars: list (ident * list init_data * V)),
+ ~In id (map (fun x: ident * list init_data * V => fst(fst x)) vars) ->
+ find_symbol (fst (add_globals ge_m vars)) id =
+ find_symbol (fst ge_m) id.
+Proof.
+ unfold find_symbol; induction vars; simpl; intros.
+ auto.
+ destruct a as [[id0 init0] var0]. simpl in *.
+ caseEq (add_globals ge_m vars); intros ge' m' EQ.
+ simpl. rewrite PTree.gso. rewrite EQ in IHvars. simpl in IHvars.
+ apply IHvars. tauto. intuition congruence.
+Qed.
+
+Lemma find_funct_ptr_exists:
+ forall (F V: Set) (p: program F V) (id: ident) (f: F),
+ list_norepet (prog_funct_names p) ->
+ list_disjoint (prog_funct_names p) (prog_var_names p) ->
+ In (id, f) (prog_funct p) ->
+ exists b, find_symbol (globalenv p) id = Some b
+ /\ find_funct_ptr (globalenv p) b = Some f.
+Proof.
+ intros until f.
+ assert (forall (fns: list (ident * F)),
+ list_norepet (map (@fst ident F) fns) ->
+ In (id, f) fns ->
+ exists b, find_symbol (add_functs (empty F) fns) id = Some b
+ /\ find_funct_ptr (add_functs (empty F) fns) b = Some f).
+ unfold find_symbol, find_funct_ptr. induction fns; intros.
+ elim H0.
+ destruct a as [id0 f0]; simpl in *. inv H.
+ unfold add_funct; simpl.
+ rewrite PTree.gsspec. destruct (peq id id0).
+ subst id0. econstructor; split. eauto.
+ replace f0 with f. apply ZMap.gss.
+ elim H0; intro. congruence. elim H3.
+ change id with (@fst ident F (id, f)). apply List.in_map. auto.
+ exploit IHfns; eauto. elim H0; intro. congruence. auto.
+ intros [b [X Y]]. exists b; split. auto. rewrite ZMap.gso. auto.
+ generalize (find_symbol_above_nextfunction _ _ X).
+ unfold block; unfold ZIndexed.t; intro; omega.
+
+ intros. exploit H; eauto. assumption. intros [b [X Y]].
+ exists b; split.
+ unfold globalenv, globalenv_initmem. rewrite find_symbol_add_globals.
+ assumption. apply list_disjoint_notin with (prog_funct_names p). assumption.
+ unfold prog_funct_names. change id with (fst (id, f)).
+ apply List.in_map; auto.
+ unfold find_funct_ptr. rewrite functions_globalenv.
+ assumption.
+Qed.
+
+Lemma find_funct_ptr_inversion:
+ forall (F V: Set) (P: F -> Prop) (p: program F V) (b: block) (f: F),
+ find_funct_ptr (globalenv p) b = Some f ->
+ exists id, In (id, f) (prog_funct p).
+Proof.
+ intros until f.
+ assert (forall fns: list (ident * F),
+ find_funct_ptr (add_functs (empty F) fns) b = Some f ->
+ exists id, In (id, f) fns).
+ unfold find_funct_ptr. induction fns; simpl.
+ rewrite ZMap.gi. congruence.
+ destruct a as [id0 f0]; simpl.
+ rewrite ZMap.gsspec. destruct (ZIndexed.eq b (nextfunction (add_functs (empty F) fns))).
+ intro. inv H. exists id0; auto.
+ intro. exploit IHfns; eauto. intros [id A]. exists id; auto.
+ unfold find_funct_ptr; rewrite functions_globalenv. intros; apply H; auto.
+Qed.
+
Lemma find_funct_ptr_prop:
forall (F V: Set) (P: F -> Prop) (p: program F V) (b: block) (f: F),
(forall id f, In (id, f) (prog_funct p) -> P f) ->
find_funct_ptr (globalenv p) b = Some f ->
P f.
Proof.
- intros until f.
- unfold find_funct_ptr. rewrite functions_globalenv.
- generalize (prog_funct p). induction l; simpl.
- rewrite ZMap.gi. intros; discriminate.
- rewrite ZMap.gsspec.
- case (ZIndexed.eq b (nextfunction (add_functs (empty F) l))); intros.
- apply H with (fst a). left. destruct a. simpl in *. congruence.
- apply IHl. intros. apply H with id. right. auto. auto.
+ intros. exploit find_funct_ptr_inversion; eauto. intros [id A]. eauto.
+Qed.
+
+Lemma find_funct_inversion:
+ forall (F V: Set) (P: F -> Prop) (p: program F V) (v: val) (f: F),
+ find_funct (globalenv p) v = Some f ->
+ exists id, In (id, f) (prog_funct p).
+Proof.
+ intros. exploit find_funct_inv; eauto. intros [b EQ]. rewrite EQ in H.
+ rewrite find_funct_find_funct_ptr in H.
+ eapply find_funct_ptr_inversion; eauto.
Qed.
Lemma find_funct_prop:
@@ -395,10 +613,7 @@ Lemma find_funct_prop:
find_funct (globalenv p) v = Some f ->
P f.
Proof.
- intros until f. unfold find_funct.
- destruct v; try (intros; discriminate).
- case (Int.eq i Int.zero); [idtac | intros; discriminate].
- intros. eapply find_funct_ptr_prop; eauto.
+ intros. exploit find_funct_inversion; eauto. intros [id A]. eauto.
Qed.
Lemma find_funct_ptr_symbol_inversion:
@@ -408,15 +623,6 @@ Lemma find_funct_ptr_symbol_inversion:
In (id, f) p.(prog_funct).
Proof.
intros until f.
- assert (forall fns,
- let g := add_functs (empty F) fns in
- PTree.get id g.(symbols) = Some b ->
- b > g.(nextfunction)).
- induction fns; simpl.
- rewrite PTree.gempty. congruence.
- rewrite PTree.gsspec. case (peq id (fst a)); intro.
- intro EQ. inversion EQ. unfold Zpred. omega.
- intros. generalize (IHfns H). unfold Zpred; omega.
assert (forall fns,
let g := add_functs (empty F) fns in
PTree.get id g.(symbols) = Some b ->
@@ -430,216 +636,336 @@ Proof.
intro EQ. inversion EQ. unfold ZIndexed.eq. rewrite zeq_true.
intro EQ2. left. destruct a. simpl in *. congruence.
intro. unfold ZIndexed.eq. rewrite zeq_false. intro. eauto.
- generalize (H _ H0). fold g. unfold block. omega.
+ generalize (find_symbol_above_nextfunction _ _ H). fold g. unfold block. omega.
assert (forall g0 m0, b < 0 ->
forall vars g m,
@add_globals F V (g0, m0) vars = (g, m) ->
PTree.get id g.(symbols) = Some b ->
PTree.get id g0.(symbols) = Some b).
induction vars; simpl.
- intros. inversion H2. auto.
+ intros. inv H1. auto.
destruct a as [[id1 init1] info1]. caseEq (add_globals (g0, m0) vars).
intros g1 m1 EQ g m EQ1. injection EQ1; simpl; clear EQ1.
unfold add_symbol; intros A B. rewrite <- B. simpl.
rewrite PTree.gsspec. case (peq id id1); intros.
- assert (b > 0). injection H2; intros. rewrite <- H3. apply nextblock_pos.
+ assert (b > 0). inv H1. apply nextblock_pos.
omegaContradiction.
eauto.
intros.
- generalize (find_funct_ptr_inv _ _ H3). intro.
+ generalize (find_funct_ptr_negative _ _ H2). intro.
pose (g := add_functs (empty F) (prog_funct p)).
- apply H0.
- apply H1 with Mem.empty (prog_vars p) (globalenv p) (init_mem p).
+ apply H.
+ apply H0 with Mem.empty (prog_vars p) (globalenv p) (init_mem p).
auto. unfold globalenv, init_mem. rewrite <- surjective_pairing.
reflexivity. assumption. rewrite <- functions_globalenv. assumption.
Qed.
(* Global environments and program transformations. *)
-Section TRANSF_PROGRAM_PARTIAL2.
+Section MATCH_PROGRAM.
Variable A B V W: Set.
-Variable transf_fun: A -> option B.
-Variable transf_var: V -> option W.
+Variable match_fun: A -> B -> Prop.
+Variable match_var: V -> W -> Prop.
Variable p: program A V.
Variable p': program B W.
-Hypothesis transf_OK:
- transform_partial_program2 transf_fun transf_var p = Some p'.
+Hypothesis match_prog:
+ match_program match_fun match_var p p'.
-Lemma add_functs_transf:
+Lemma add_functs_match:
forall (fns: list (ident * A)) (tfns: list (ident * B)),
- map_partial transf_fun fns = Some tfns ->
+ list_forall2 (match_funct_entry match_fun) fns tfns ->
let r := add_functs (empty A) fns in
let tr := add_functs (empty B) tfns in
nextfunction tr = nextfunction r /\
symbols tr = symbols r /\
forall (b: block) (f: A),
ZMap.get b (functions r) = Some f ->
- ZMap.get b (functions tr) = transf_fun f /\ transf_fun f <> None.
+ exists tf, ZMap.get b (functions tr) = Some tf /\ match_fun f tf.
Proof.
- induction fns; simpl.
+ induction 1; simpl.
- intros; injection H; intro; subst tfns.
- simpl. split. reflexivity. split. reflexivity.
+ split. reflexivity. split. reflexivity.
intros b f; repeat (rewrite ZMap.gi). intros; discriminate.
- intro tfns. destruct a. caseEq (transf_fun a). intros a' TA.
- caseEq (map_partial transf_fun fns). intros l TPP EQ.
- injection EQ; intro; subst tfns.
- clear EQ. simpl.
- generalize (IHfns l TPP).
- intros [HR1 [HR2 HR3]].
- rewrite HR1. rewrite HR2.
- split. reflexivity.
- split. reflexivity.
+ destruct a1 as [id1 fn1]. destruct b1 as [id2 fn2].
+ simpl. red in H. destruct H.
+ destruct IHlist_forall2 as [X [Y Z]].
+ rewrite X. rewrite Y.
+ split. auto.
+ split. congruence.
intros b f.
- case (zeq b (nextfunction (add_functs (empty A) fns))); intro.
- subst b. repeat (rewrite ZMap.gss).
- intro EQ; injection EQ; intro; subst f; clear EQ.
- rewrite TA. split. auto. discriminate.
- repeat (rewrite ZMap.gso; auto).
+ repeat (rewrite ZMap.gsspec).
+ destruct (ZIndexed.eq b (nextfunction (add_functs (empty A) al))).
+ intro EQ; inv EQ. exists fn2; auto.
+ auto.
+Qed.
- intros; discriminate.
- intros; discriminate.
+Lemma add_functs_rev_match:
+ forall (fns: list (ident * A)) (tfns: list (ident * B)),
+ list_forall2 (match_funct_entry match_fun) fns tfns ->
+ let r := add_functs (empty A) fns in
+ let tr := add_functs (empty B) tfns in
+ nextfunction tr = nextfunction r /\
+ symbols tr = symbols r /\
+ forall (b: block) (tf: B),
+ ZMap.get b (functions tr) = Some tf ->
+ exists f, ZMap.get b (functions r) = Some f /\ match_fun f tf.
+Proof.
+ induction 1; simpl.
+
+ split. reflexivity. split. reflexivity.
+ intros b f; repeat (rewrite ZMap.gi). intros; discriminate.
+
+ destruct a1 as [id1 fn1]. destruct b1 as [id2 fn2].
+ simpl. red in H. destruct H.
+ destruct IHlist_forall2 as [X [Y Z]].
+ rewrite X. rewrite Y.
+ split. auto.
+ split. congruence.
+ intros b f.
+ repeat (rewrite ZMap.gsspec).
+ destruct (ZIndexed.eq b (nextfunction (add_functs (empty A) al))).
+ intro EQ; inv EQ. exists fn1; auto.
+ auto.
Qed.
-Lemma mem_add_globals_transf:
+Lemma mem_add_globals_match:
forall (g1: genv A) (g2: genv B) (m: mem)
(vars: list (ident * list init_data * V))
(tvars: list (ident * list init_data * W)),
- map_partial transf_var vars = Some tvars ->
+ list_forall2 (match_var_entry match_var) vars tvars ->
snd (add_globals (g1, m) vars) = snd (add_globals (g2, m) tvars).
Proof.
- induction vars; simpl.
- intros. inversion H. reflexivity.
- intro. destruct a as [[id1 init1] info1].
- caseEq (transf_var info1); try congruence.
- intros tinfo1 EQ1.
- caseEq (map_partial transf_var vars); try congruence.
- intros tvars' EQ2 EQ3.
- inversion EQ3. simpl.
- generalize (IHvars _ EQ2).
- destruct (add_globals (g1, m) vars).
- destruct (add_globals (g2, m) tvars').
+ induction 1; simpl.
+ auto.
+ destruct a1 as [[id1 init1] info1].
+ destruct b1 as [[id2 init2] info2].
+ red in H. destruct H as [X [Y Z]]. subst id2 init2.
+ generalize IHlist_forall2.
+ destruct (add_globals (g1, m) al).
+ destruct (add_globals (g2, m) bl).
simpl. intro. subst m1. auto.
Qed.
-Lemma symbols_add_globals_transf:
+Lemma symbols_add_globals_match:
forall (g1: genv A) (g2: genv B) (m: mem),
symbols g1 = symbols g2 ->
forall (vars: list (ident * list init_data * V))
(tvars: list (ident * list init_data * W)),
- map_partial transf_var vars = Some tvars ->
+ list_forall2 (match_var_entry match_var) vars tvars ->
symbols (fst (add_globals (g1, m) vars)) =
symbols (fst (add_globals (g2, m) tvars)).
Proof.
- induction vars; simpl.
- intros. inversion H0. assumption.
- intro. destruct a as [[id1 init1] info1].
- caseEq (transf_var info1); try congruence. intros tinfo1 EQ1.
- caseEq (map_partial transf_var vars); try congruence.
- intros tvars' EQ2 EQ3. inversion EQ3; simpl.
- generalize (IHvars _ EQ2).
- generalize (mem_add_globals_transf g1 g2 m vars EQ2).
- destruct (add_globals (g1, m) vars).
- destruct (add_globals (g2, m) tvars').
+ induction 2; simpl.
+ auto.
+ destruct a1 as [[id1 init1] info1].
+ destruct b1 as [[id2 init2] info2].
+ red in H0. destruct H0 as [X [Y Z]]. subst id2 init2.
+ generalize IHlist_forall2.
+ generalize (mem_add_globals_match g1 g2 m H1).
+ destruct (add_globals (g1, m) al).
+ destruct (add_globals (g2, m) bl).
simpl. intros. congruence.
Qed.
-(*
-Lemma prog_funct_transf_OK:
- transf_partial_program transf p.(prog_funct) = Some p'.(prog_funct).
+Theorem find_funct_ptr_match:
+ forall (b: block) (f: A),
+ find_funct_ptr (globalenv p) b = Some f ->
+ exists tf, find_funct_ptr (globalenv p') b = Some tf /\ match_fun f tf.
Proof.
- generalize transf_OK; unfold transform_partial_program.
- case (transf_partial_program transf (prog_funct p)); simpl; intros.
- injection transf_OK0; intros; subst p'. reflexivity.
- discriminate.
+ intros until f. destruct match_prog as [X [Y Z]].
+ destruct (add_functs_match X) as [P [Q R]].
+ unfold find_funct_ptr. repeat rewrite functions_globalenv.
+ auto.
Qed.
-*)
-Theorem find_funct_ptr_transf_partial2:
- forall (b: block) (f: A),
- find_funct_ptr (globalenv p) b = Some f ->
- find_funct_ptr (globalenv p') b = transf_fun f /\ transf_fun f <> None.
+Theorem find_funct_ptr_rev_match:
+ forall (b: block) (tf: B),
+ find_funct_ptr (globalenv p') b = Some tf ->
+ exists f, find_funct_ptr (globalenv p) b = Some f /\ match_fun f tf.
Proof.
- intros until f. functional inversion transf_OK.
- destruct (add_functs_transf _ H0) as [P [Q R]].
- unfold find_funct_ptr. repeat rewrite functions_globalenv. simpl.
+ intros until tf. destruct match_prog as [X [Y Z]].
+ destruct (add_functs_rev_match X) as [P [Q R]].
+ unfold find_funct_ptr. repeat rewrite functions_globalenv.
auto.
Qed.
-Theorem find_funct_transf_partial2:
+Theorem find_funct_match:
forall (v: val) (f: A),
find_funct (globalenv p) v = Some f ->
- find_funct (globalenv p') v = transf_fun f /\ transf_fun f <> None.
+ exists tf, find_funct (globalenv p') v = Some tf /\ match_fun f tf.
Proof.
intros until f. unfold find_funct.
case v; try (intros; discriminate).
intros b ofs.
case (Int.eq ofs Int.zero); try (intros; discriminate).
- apply find_funct_ptr_transf_partial2.
+ apply find_funct_ptr_match.
Qed.
-Lemma symbols_init_transf2:
+Theorem find_funct_rev_match:
+ forall (v: val) (tf: B),
+ find_funct (globalenv p') v = Some tf ->
+ exists f, find_funct (globalenv p) v = Some f /\ match_fun f tf.
+Proof.
+ intros until tf. unfold find_funct.
+ case v; try (intros; discriminate).
+ intros b ofs.
+ case (Int.eq ofs Int.zero); try (intros; discriminate).
+ apply find_funct_ptr_rev_match.
+Qed.
+
+Lemma symbols_init_match:
symbols (globalenv p') = symbols (globalenv p).
Proof.
unfold globalenv. unfold globalenv_initmem.
- functional inversion transf_OK.
- destruct (add_functs_transf _ H0) as [P [Q R]].
- simpl. symmetry. apply symbols_add_globals_transf. auto. auto.
+ destruct match_prog as [X [Y Z]].
+ destruct (add_functs_match X) as [P [Q R]].
+ simpl. symmetry. apply symbols_add_globals_match. auto. auto.
Qed.
-Theorem find_symbol_transf_partial2:
+Theorem find_symbol_match:
forall (s: ident),
find_symbol (globalenv p') s = find_symbol (globalenv p) s.
Proof.
intros. unfold find_symbol.
- rewrite symbols_init_transf2. auto.
+ rewrite symbols_init_match. auto.
+Qed.
+
+Theorem init_mem_match:
+ init_mem p' = init_mem p.
+Proof.
+ unfold init_mem. unfold globalenv_initmem.
+ destruct match_prog as [X [Y Z]].
+ symmetry. apply mem_add_globals_match. auto.
+Qed.
+
+End MATCH_PROGRAM.
+
+Section TRANSF_PROGRAM_PARTIAL2.
+
+Variable A B V W: Set.
+Variable transf_fun: A -> res B.
+Variable transf_var: V -> res W.
+Variable p: program A V.
+Variable p': program B W.
+Hypothesis transf_OK:
+ transform_partial_program2 transf_fun transf_var p = OK p'.
+
+Remark prog_match:
+ match_program
+ (fun fd tfd => transf_fun fd = OK tfd)
+ (fun info tinfo => transf_var info = OK tinfo)
+ p p'.
+Proof.
+ apply transform_partial_program2_match; auto.
+Qed.
+
+Theorem find_funct_ptr_transf_partial2:
+ forall (b: block) (f: A),
+ find_funct_ptr (globalenv p) b = Some f ->
+ exists f',
+ find_funct_ptr (globalenv p') b = Some f' /\ transf_fun f = OK f'.
+Proof.
+ intros.
+ exploit find_funct_ptr_match. eexact prog_match. eauto.
+ intros [tf [X Y]]. exists tf; auto.
+Qed.
+
+Theorem find_funct_ptr_rev_transf_partial2:
+ forall (b: block) (tf: B),
+ find_funct_ptr (globalenv p') b = Some tf ->
+ exists f, find_funct_ptr (globalenv p) b = Some f /\ transf_fun f = OK tf.
+Proof.
+ intros.
+ exploit find_funct_ptr_rev_match. eexact prog_match. eauto. auto.
+Qed.
+
+Theorem find_funct_transf_partial2:
+ forall (v: val) (f: A),
+ find_funct (globalenv p) v = Some f ->
+ exists f',
+ find_funct (globalenv p') v = Some f' /\ transf_fun f = OK f'.
+Proof.
+ intros.
+ exploit find_funct_match. eexact prog_match. eauto.
+ intros [tf [X Y]]. exists tf; auto.
+Qed.
+
+Theorem find_funct_rev_transf_partial2:
+ forall (v: val) (tf: B),
+ find_funct (globalenv p') v = Some tf ->
+ exists f, find_funct (globalenv p) v = Some f /\ transf_fun f = OK tf.
+Proof.
+ intros.
+ exploit find_funct_rev_match. eexact prog_match. eauto. auto.
+Qed.
+
+Theorem find_symbol_transf_partial2:
+ forall (s: ident),
+ find_symbol (globalenv p') s = find_symbol (globalenv p) s.
+Proof.
+ intros. eapply find_symbol_match. eexact prog_match.
Qed.
Theorem init_mem_transf_partial2:
init_mem p' = init_mem p.
Proof.
- unfold init_mem. unfold globalenv_initmem.
- functional inversion transf_OK.
- simpl. symmetry. apply mem_add_globals_transf. auto.
+ intros. eapply init_mem_match. eexact prog_match.
Qed.
End TRANSF_PROGRAM_PARTIAL2.
-
Section TRANSF_PROGRAM_PARTIAL.
Variable A B V: Set.
-Variable transf: A -> option B.
+Variable transf: A -> res B.
Variable p: program A V.
Variable p': program B V.
-Hypothesis transf_OK: transform_partial_program transf p = Some p'.
+Hypothesis transf_OK: transform_partial_program transf p = OK p'.
Remark transf2_OK:
- transform_partial_program2 transf (fun x => Some x) p = Some p'.
+ transform_partial_program2 transf (fun x => OK x) p = OK p'.
Proof.
rewrite <- transf_OK. unfold transform_partial_program2, transform_partial_program.
- destruct (map_partial transf (prog_funct p)); auto.
+ destruct (map_partial prefix_funct_name transf (prog_funct p)); auto.
rewrite map_partial_identity; auto.
Qed.
Theorem find_funct_ptr_transf_partial:
forall (b: block) (f: A),
find_funct_ptr (globalenv p) b = Some f ->
- find_funct_ptr (globalenv p') b = transf f /\ transf f <> None.
+ exists f',
+ find_funct_ptr (globalenv p') b = Some f' /\ transf f = OK f'.
Proof.
exact (@find_funct_ptr_transf_partial2 _ _ _ _ _ _ _ _ transf2_OK).
Qed.
+Theorem find_funct_ptr_rev_transf_partial:
+ forall (b: block) (tf: B),
+ find_funct_ptr (globalenv p') b = Some tf ->
+ exists f, find_funct_ptr (globalenv p) b = Some f /\ transf f = OK tf.
+Proof.
+ exact (@find_funct_ptr_rev_transf_partial2 _ _ _ _ _ _ _ _ transf2_OK).
+Qed.
+
Theorem find_funct_transf_partial:
forall (v: val) (f: A),
find_funct (globalenv p) v = Some f ->
- find_funct (globalenv p') v = transf f /\ transf f <> None.
+ exists f',
+ find_funct (globalenv p') v = Some f' /\ transf f = OK f'.
Proof.
exact (@find_funct_transf_partial2 _ _ _ _ _ _ _ _ transf2_OK).
Qed.
+Theorem find_funct_rev_transf_partial:
+ forall (v: val) (tf: B),
+ find_funct (globalenv p') v = Some tf ->
+ exists f, find_funct (globalenv p) v = Some f /\ transf f = OK tf.
+Proof.
+ exact (@find_funct_rev_transf_partial2 _ _ _ _ _ _ _ _ transf2_OK).
+Qed.
+
Theorem find_symbol_transf_partial:
forall (s: ident),
find_symbol (globalenv p') s = find_symbol (globalenv p) s.
@@ -663,7 +989,7 @@ Variable p: program A V.
Let tp := transform_program transf p.
Remark transf_OK:
- transform_partial_program (fun x => Some (transf x)) p = Some tp.
+ transform_partial_program (fun x => OK (transf x)) p = OK tp.
Proof.
unfold tp, transform_program, transform_partial_program.
rewrite map_partial_total. reflexivity.
@@ -676,7 +1002,16 @@ Theorem find_funct_ptr_transf:
Proof.
intros.
destruct (@find_funct_ptr_transf_partial _ _ _ _ _ _ transf_OK _ _ H)
- as [X Y]. auto.
+ as [f' [X Y]]. congruence.
+Qed.
+
+Theorem find_funct_ptr_rev_transf:
+ forall (b: block) (tf: B),
+ find_funct_ptr (globalenv tp) b = Some tf ->
+ exists f, find_funct_ptr (globalenv p) b = Some f /\ transf f = tf.
+Proof.
+ intros. exploit find_funct_ptr_rev_transf_partial. eexact transf_OK. eauto.
+ intros [f [X Y]]. exists f; split. auto. congruence.
Qed.
Theorem find_funct_transf:
@@ -686,7 +1021,16 @@ Theorem find_funct_transf:
Proof.
intros.
destruct (@find_funct_transf_partial _ _ _ _ _ _ transf_OK _ _ H)
- as [X Y]. auto.
+ as [f' [X Y]]. congruence.
+Qed.
+
+Theorem find_funct_rev_transf:
+ forall (v: val) (tf: B),
+ find_funct (globalenv tp) v = Some tf ->
+ exists f, find_funct (globalenv p) v = Some f /\ transf f = tf.
+Proof.
+ intros. exploit find_funct_rev_transf_partial. eexact transf_OK. eauto.
+ intros [f [X Y]]. exists f; split. auto. congruence.
Qed.
Theorem find_symbol_transf:
diff --git a/common/Main.v b/common/Main.v
index f472ec3a84bd8a11032c20f6bddc5cbb93efc04c..33bc7830d486726dae4b644cda11cb2147b182d1 100644
--- a/common/Main.v
+++ b/common/Main.v
@@ -1,40 +1,48 @@
-(** The compiler back-end and its proof of semantic preservation *)
+(** The whole compiler and its proof of semantic preservation *)
(** Libraries. *)
Require Import Coqlib.
Require Import Maps.
+Require Import Errors.
Require Import AST.
Require Import Values.
+Require Import Smallstep.
(** Languages (syntax and semantics). *)
Require Csyntax.
Require Csem.
Require Csharpminor.
Require Cminor.
+Require CminorSel.
Require RTL.
Require LTL.
+Require LTLin.
Require Linear.
Require Mach.
Require PPC.
(** Translation passes. *)
Require Cshmgen.
Require Cminorgen.
+Require Selection.
Require RTLgen.
Require Constprop.
Require CSE.
Require Allocation.
Require Tunneling.
Require Linearize.
+Require Reload.
Require Stacking.
Require PPCgen.
(** Type systems. *)
Require Ctyping.
Require RTLtyping.
Require LTLtyping.
+Require LTLintyping.
Require Lineartyping.
Require Machtyping.
(** Proofs of semantic preservation and typing preservation. *)
Require Cshmgenproof3.
Require Cminorgenproof.
+Require Selectionproof.
Require RTLgenproof.
Require Constpropproof.
Require CSEproof.
@@ -44,266 +52,234 @@ Require Tunnelingproof.
Require Tunnelingtyping.
Require Linearizeproof.
Require Linearizetyping.
+Require Reloadproof.
+Require Reloadtyping.
Require Stackingproof.
Require Stackingtyping.
-Require Machabstr2mach.
+Require Machabstr2concr.
Require PPCgenproof.
+Open Local Scope string_scope.
+
(** * Composing the translation passes *)
(** We first define useful monadic composition operators,
along with funny (but convenient) notations. *)
-Definition apply_total (A B: Set) (x: option A) (f: A -> B) : option B :=
- match x with None => None | Some x1 => Some (f x1) end.
+Definition apply_total (A B: Set) (x: res A) (f: A -> B) : res B :=
+ match x with Error msg => Error msg | OK x1 => OK (f x1) end.
Definition apply_partial (A B: Set)
- (x: option A) (f: A -> option B) : option B :=
- match x with None => None | Some x1 => f x1 end.
+ (x: res A) (f: A -> res B) : res B :=
+ match x with Error msg => Error msg | OK x1 => f x1 end.
Notation "a @@@ b" :=
(apply_partial _ _ a b) (at level 50, left associativity).
Notation "a @@ b" :=
(apply_total _ _ a b) (at level 50, left associativity).
-(** We define two translation functions for whole programs: one starting with
- a C program, the other with a Cminor program. Both
- translations produce PPC programs ready for pretty-printing and
- assembling.
+(** We define three translation functions for whole programs: one
+ starting with a C program, one with a Cminor program, one with an
+ RTL program. The three translations produce PPC programs ready for
+ pretty-printing and assembling.
- There are two ways to compose the compiler passes. The first translates
- every function from the Cminor program from Cminor to RTL, then to LTL, etc,
- all the way to PPC, and iterates this transformation for every function.
- The second translates the whole Cminor program to a RTL program, then to
- an LTL program, etc. We follow the first approach because it has lower
- memory requirements.
+ There are two ways to compose the compiler passes. The first
+ translates every function from the Cminor program from Cminor to
+ RTL, then to LTL, etc, all the way to PPC, and iterates this
+ transformation for every function. The second translates the whole
+ Cminor program to a RTL program, then to an LTL program, etc.
+ Between Cminor and PPC, we follow the first approach because it has
+ lower memory requirements. The translation from Clight to PPC
+ follows the second approach.
- The translation of a Cminor function to a PPC function is as follows. *)
+ The translation of an RTL function to a PPC function is as follows. *)
-Definition transf_cminor_fundef (f: Cminor.fundef) : option PPC.fundef :=
- Some f
- @@@ RTLgen.transl_fundef
+Definition transf_rtl_fundef (f: RTL.fundef) : res PPC.fundef :=
+ OK f
@@ Constprop.transf_fundef
@@ CSE.transf_fundef
@@@ Allocation.transf_fundef
@@ Tunneling.tunnel_fundef
@@ Linearize.transf_fundef
+ @@ Reload.transf_fundef
@@@ Stacking.transf_fundef
@@@ PPCgen.transf_fundef.
+(* Here is the translation of a Cminor function to a PPC function. *)
+
+Definition transf_cminor_fundef (f: Cminor.fundef) : res PPC.fundef :=
+ OK f
+ @@ Selection.sel_fundef
+ @@@ RTLgen.transl_fundef
+ @@@ transf_rtl_fundef.
+
(** The corresponding translations for whole program follow. *)
-Definition transf_cminor_program (p: Cminor.program) : option PPC.program :=
+Definition transf_rtl_program (p: RTL.program) : res PPC.program :=
+ transform_partial_program transf_rtl_fundef p.
+
+Definition transf_cminor_program (p: Cminor.program) : res PPC.program :=
transform_partial_program transf_cminor_fundef p.
-Definition transf_c_program (p: Csyntax.program) : option PPC.program :=
+Definition transf_c_program (p: Csyntax.program) : res PPC.program :=
match Ctyping.typecheck_program p with
- | false => None
+ | false =>
+ Error (msg "Ctyping: type error")
| true =>
- Some p
+ OK p
@@@ Cshmgen.transl_program
@@@ Cminorgen.transl_program
@@@ transf_cminor_program
end.
-(** * Equivalence with whole program transformations *)
-
-(** To prove semantic preservation for the whole compiler, it is easier to reason
- over the second way to compose the compiler pass: the one that translate
- whole programs through each compiler pass. We now define this second translation
- and prove that it produces the same PPC programs as the first translation. *)
-
-Definition transf_cminor_program2 (p: Cminor.program) : option PPC.program :=
- Some p
- @@@ RTLgen.transl_program
- @@ Constprop.transf_program
- @@ CSE.transf_program
- @@@ Allocation.transf_program
- @@ Tunneling.tunnel_program
- @@ Linearize.transf_program
- @@@ Stacking.transf_program
- @@@ PPCgen.transf_program.
+(** The following lemmas help reason over compositions of passes. *)
Lemma map_partial_compose:
forall (X A B C: Set)
- (f1: A -> option B) (f2: B -> option C)
- (p: list (X * A)),
- map_partial f1 p @@@ map_partial f2 =
- map_partial (fun f => f1 f @@@ f2) p.
+ (ctx: X -> errmsg)
+ (f1: A -> res B) (f2: B -> res C)
+ (pa: list (X * A)) (pc: list (X * C)),
+ map_partial ctx (fun f => f1 f @@@ f2) pa = OK pc ->
+ exists pb, map_partial ctx f1 pa = OK pb /\ map_partial ctx f2 pb = OK pc.
Proof.
- induction p. simpl. auto.
- simpl. destruct a. destruct (f1 a).
- simpl. simpl in IHp. destruct (map_partial f1 p).
- simpl. simpl in IHp. destruct (f2 b).
- destruct (map_partial f2 l).
- rewrite <- IHp. auto.
- rewrite <- IHp. auto.
- auto.
- simpl. rewrite <- IHp. simpl. destruct (f2 b); auto.
- simpl. auto.
+ induction pa; simpl.
+ intros. inv H. econstructor; eauto.
+ intro pc. destruct a as [x a].
+ caseEq (f1 a); simpl; try congruence. intros b F1.
+ caseEq (f2 b); simpl; try congruence. intros c F2 EQ.
+ monadInv EQ. exploit IHpa; eauto. intros [pb [P Q]].
+ rewrite P; simpl.
+ exists ((x, b) :: pb); split. auto. simpl. rewrite F2. rewrite Q. auto.
Qed.
-(*
-Lemma transform_partial_program2_compose:
- forall (A B C V W X: Set)
- (f1: A -> option B) (g1: V -> option W)
- (f2: B -> option C) (g2: W -> option X)
- (p: program A V),
- transform_partial_program2 f1 g1 p @@@
- (fun p' => transform_partial_program2 f2 g2 p') =
- transform_partial_program2 (fun x => f1 x @@@ f2) (fun x => g1 x @@@ g2) p.
+Lemma transform_partial_program_compose:
+ forall (A B C V: Set)
+ (f1: A -> res B) (f2: B -> res C)
+ (pa: program A V) (pc: program C V),
+ transform_partial_program (fun f => f1 f @@@ f2) pa = OK pc ->
+ exists pb, transform_partial_program f1 pa = OK pb /\
+ transform_partial_program f2 pb = OK pc.
Proof.
- unfold transform_partial_program2; intros.
- rewrite <- map_partial_compose; simpl.
- rewrite <- map_partial_compose; simpl.
- destruct (map_partial f1 (prog_funct p)); simpl; auto.
- destruct (map_partial g1 (prog_vars p)); simpl; auto.
- destruct (map_partial f2 l); auto.
+ intros. monadInv H.
+ exploit map_partial_compose; eauto. intros [xb [P Q]].
+ exists (mkprogram xb (prog_main pa) (prog_vars pa)); split.
+ unfold transform_partial_program. rewrite P; auto.
+ unfold transform_partial_program. simpl. rewrite Q; auto.
Qed.
-Lemma transform_program_partial2_partial:
- forall (A B V: Set) (f: A -> option B) (p: program A V),
- transform_partial_program f p =
- transform_partial_program2 f (fun x => Some x) p.
+Lemma transform_program_partial_program:
+ forall (A B V: Set) (f: A -> B) (p: program A V) (tp: program B V),
+ transform_partial_program (fun x => OK (f x)) p = OK tp ->
+ transform_program f p = tp.
Proof.
- intros. unfold transform_partial_program, transform_partial_program2.
- rewrite map_partial_identity. auto.
+ intros until tp. unfold transform_partial_program.
+ rewrite map_partial_total. simpl. intros. inv H. auto.
Qed.
-Lemma apply_partial_transf_program:
- forall (A B V: Set) (f: A -> option B) (x: option (program A V)),
- x @@@ (fun p => transform_partial_program f p) =
- x @@@ (fun p => transform_partial_program2 f (fun x => Some x) p).
-Proof.
- intros. unfold apply_partial.
- destruct x. apply transform_program_partial2_partial. auto.
-Qed.
-*)
-Lemma transform_partial_program_compose:
+Lemma transform_program_compose:
forall (A B C V: Set)
- (f1: A -> option B) (f2: B -> option C)
- (p: program A V),
- transform_partial_program f1 p @@@
- (fun p' => transform_partial_program f2 p') =
- transform_partial_program (fun f => f1 f @@@ f2) p.
+ (f1: A -> res B) (f2: B -> C)
+ (pa: program A V) (pc: program C V),
+ transform_partial_program (fun f => f1 f @@ f2) pa = OK pc ->
+ exists pb, transform_partial_program f1 pa = OK pb /\
+ transform_program f2 pb = pc.
Proof.
- unfold transform_partial_program; intros.
- rewrite <- map_partial_compose. simpl.
- destruct (map_partial f1 (prog_funct p)); simpl.
- auto. auto.
+ intros.
+ replace (fun f : A => f1 f @@ f2)
+ with (fun f : A => f1 f @@@ (fun x => OK (f2 x))) in H.
+ exploit transform_partial_program_compose; eauto.
+ intros [pb [X Y]]. exists pb; split. auto.
+ apply transform_program_partial_program. auto.
+ apply extensionality; intro. destruct(f1 x); auto.
Qed.
-Lemma transform_program_partial_total:
- forall (A B V: Set) (f: A -> B) (p: program A V),
- Some (transform_program f p) =
- transform_partial_program (fun x => Some (f x)) p.
+Lemma transform_partial_program_identity:
+ forall (A V: Set) (pa pb: program A V),
+ transform_partial_program (@OK A) pa = OK pb ->
+ pa = pb.
Proof.
- intros. unfold transform_program, transform_partial_program.
- rewrite map_partial_total. auto.
+ intros until pb. unfold transform_partial_program.
+ replace (@OK A) with (fun b => @OK A b).
+ rewrite map_partial_identity. simpl. destruct pa; simpl; congruence.
+ apply extensionality; auto.
Qed.
-Lemma apply_total_transf_program:
- forall (A B V: Set) (f: A -> B) (x: option (program A V)),
- x @@ (fun p => transform_program f p) =
- x @@@ (fun p => transform_partial_program (fun x => Some (f x)) p).
-Proof.
- intros. unfold apply_total, apply_partial.
- destruct x. apply transform_program_partial_total. auto.
-Qed.
+(** * Semantic preservation *)
-Lemma transf_cminor_program_equiv:
- forall p, transf_cminor_program2 p = transf_cminor_program p.
-Proof.
- intro. unfold transf_cminor_program, transf_cminor_program2, transf_cminor_fundef.
- simpl.
- unfold RTLgen.transl_program,
- Constprop.transf_program, RTL.program.
- rewrite apply_total_transf_program.
- rewrite transform_partial_program_compose.
- unfold CSE.transf_program, RTL.program.
- rewrite apply_total_transf_program.
- rewrite transform_partial_program_compose.
- unfold Allocation.transf_program,
- LTL.program, RTL.program.
- rewrite transform_partial_program_compose.
- unfold Tunneling.tunnel_program, LTL.program.
- rewrite apply_total_transf_program.
- rewrite transform_partial_program_compose.
- unfold Linearize.transf_program, LTL.program, Linear.program.
- rewrite apply_total_transf_program.
- rewrite transform_partial_program_compose.
- unfold Stacking.transf_program, Linear.program, Mach.program.
- rewrite transform_partial_program_compose.
- unfold PPCgen.transf_program, Mach.program, PPC.program.
- rewrite transform_partial_program_compose.
- reflexivity.
-Qed.
+(** We prove that the [transf_program] translations preserve semantics.
+ The proof composes the semantic preservation results for each pass.
+ This establishes the correctness of the whole compiler! *)
-(*
-Lemma transf_csharpminor_program_equiv:
- forall p, transf_csharpminor_program2 p = transf_csharpminor_program p.
+Theorem transf_rtl_program_correct:
+ forall p tp beh,
+ transf_rtl_program p = OK tp ->
+ RTL.exec_program p beh ->
+ PPC.exec_program tp beh.
Proof.
- intros.
- unfold transf_csharpminor_program2, transf_csharpminor_program, transf_csharpminor_fundef.
- simpl.
- replace transf_cminor_program2 with transf_cminor_program.
- unfold transf_cminor_program, Cminorgen.transl_program, Cminor.program, PPC.program.
- rewrite apply_partial_transf_program.
- rewrite transform_partial_program2_compose.
- reflexivity.
- symmetry. apply extensionality. exact transf_cminor_program_equiv.
-Qed.
-*)
+ intros. unfold transf_rtl_program, transf_rtl_fundef in H.
+ destruct (transform_partial_program_compose _ _ _ _ _ _ _ _ H) as [p7 [H7 P7]].
+ clear H.
+ destruct (transform_partial_program_compose _ _ _ _ _ _ _ _ H7) as [p6 [H6 P6]].
+ clear H7.
+ destruct (transform_partial_program_compose _ _ _ _ _ _ _ _ H6) as [p5 [H5 P5]].
+ clear H6. generalize (transform_program_partial_program _ _ _ _ _ _ P5). clear P5. intro P5.
+ destruct (transform_partial_program_compose _ _ _ _ _ _ _ _ H5) as [p4 [H4 P4]].
+ clear H5. generalize (transform_program_partial_program _ _ _ _ _ _ P4). clear P4. intro P4.
+ destruct (transform_partial_program_compose _ _ _ _ _ _ _ _ H4) as [p3 [H3 P3]].
+ clear H4. generalize (transform_program_partial_program _ _ _ _ _ _ P3). clear P3. intro P3.
+ destruct (transform_partial_program_compose _ _ _ _ _ _ _ _ H3) as [p2 [H2 P2]].
+ clear H3.
+ destruct (transform_program_compose _ _ _ _ _ _ _ _ H2) as [p1 [H1 P1]].
+ clear H2.
+ destruct (transform_program_compose _ _ _ _ _ _ _ _ H1) as [p0 [H00 P0]].
+ clear H1.
+ generalize (transform_partial_program_identity _ _ _ _ H00). clear H00. intro. subst p0.
-(** * Semantic preservation *)
+ assert (WT3 : LTLtyping.wt_program p3).
+ apply Alloctyping.program_typing_preserved with p2. auto.
+ assert (WT4 : LTLtyping.wt_program p4).
+ subst p4. apply Tunnelingtyping.program_typing_preserved. auto.
+ assert (WT5 : LTLintyping.wt_program p5).
+ subst p5. apply Linearizetyping.program_typing_preserved. auto.
+ assert (WT6 : Lineartyping.wt_program p6).
+ subst p6. apply Reloadtyping.program_typing_preserved. auto.
+ assert (WT7: Machtyping.wt_program p7).
+ apply Stackingtyping.program_typing_preserved with p6. auto. auto.
-(** We prove that the [transf_program] translations preserve semantics. The proof
- composes the semantic preservation results for each pass.
- This establishes the correctness of the whole compiler! *)
+ apply PPCgenproof.transf_program_correct with p7; auto.
+ apply Machabstr2concr.exec_program_equiv; auto.
+ apply Stackingproof.transf_program_correct with p6; auto.
+ subst p6; apply Reloadproof.transf_program_correct; auto.
+ subst p5; apply Linearizeproof.transf_program_correct; auto.
+ subst p4; apply Tunnelingproof.transf_program_correct.
+ apply Allocproof.transf_program_correct with p2; auto.
+ subst p2; apply CSEproof.transf_program_correct.
+ subst p1; apply Constpropproof.transf_program_correct. auto.
+Qed.
Theorem transf_cminor_program_correct:
forall p tp t n,
- transf_cminor_program p = Some tp ->
+ transf_cminor_program p = OK tp ->
Cminor.exec_program p t (Vint n) ->
- PPC.exec_program tp t (Vint n).
+ PPC.exec_program tp (Terminates t n).
Proof.
- intros until n.
- rewrite <- transf_cminor_program_equiv.
- unfold transf_cminor_program2.
- simpl. caseEq (RTLgen.transl_program p). intros p1 EQ1.
- simpl. set (p2 := CSE.transf_program (Constprop.transf_program p1)).
- caseEq (Allocation.transf_program p2). intros p3 EQ3.
- simpl. set (p4 := Tunneling.tunnel_program p3).
- set (p5 := Linearize.transf_program p4).
- caseEq (Stacking.transf_program p5). intros p6 EQ6.
- simpl. intros EQTP EXEC.
- assert (WT3 : LTLtyping.wt_program p3).
- apply Alloctyping.program_typing_preserved with p2. auto.
- assert (WT4 : LTLtyping.wt_program p4).
- unfold p4. apply Tunnelingtyping.program_typing_preserved. auto.
- assert (WT5 : Lineartyping.wt_program p5).
- unfold p5. apply Linearizetyping.program_typing_preserved. auto.
- assert (WT6: Machtyping.wt_program p6).
- apply Stackingtyping.program_typing_preserved with p5. auto. auto.
- apply PPCgenproof.transf_program_correct with p6; auto.
- apply Machabstr2mach.exec_program_equiv; auto.
- apply Stackingproof.transl_program_correct with p5; auto.
- unfold p5; apply Linearizeproof.transf_program_correct.
- unfold p4; apply Tunnelingproof.transf_program_correct.
- apply Allocproof.transl_program_correct with p2; auto.
- unfold p2; apply CSEproof.transf_program_correct;
- apply Constpropproof.transf_program_correct.
- apply RTLgenproof.transl_program_correct with p; auto.
- simpl; intros; discriminate.
- simpl; intros; discriminate.
- simpl; intros; discriminate.
+ intros. unfold transf_cminor_program, transf_cminor_fundef in H.
+ destruct (transform_partial_program_compose _ _ _ _ _ _ _ _ H) as [p3 [H3 P3]].
+ clear H.
+ destruct (transform_partial_program_compose _ _ _ _ _ _ _ _ H3) as [p2 [H2 P2]].
+ clear H3.
+ destruct (transform_program_compose _ _ _ _ _ _ _ _ H2) as [p1 [H1 P1]].
+ generalize (transform_partial_program_identity _ _ _ _ H1). clear H1. intro. subst p1.
+ apply transf_rtl_program_correct with p3. auto.
+ apply RTLgenproof.transl_program_correct with p2; auto.
+ rewrite <- P1. apply Selectionproof.sel_program_correct; auto.
Qed.
Theorem transf_c_program_correct:
forall p tp t n,
- transf_c_program p = Some tp ->
+ transf_c_program p = OK tp ->
Csem.exec_program p t (Vint n) ->
- PPC.exec_program tp t (Vint n).
+ PPC.exec_program tp (Terminates t n).
Proof.
intros until n; unfold transf_c_program; simpl.
caseEq (Ctyping.typecheck_program p); try congruence; intro.
diff --git a/common/Mem.v b/common/Mem.v
index 679c41e17f79d9d2678f473be72bbed4a06e5aa1..6b66d9da5225bd79d164859d1f2e9918fbdc5879 100644
--- a/common/Mem.v
+++ b/common/Mem.v
@@ -1,11 +1,11 @@
(** This file develops the memory model that is used in the dynamic
- semantics of all the languages of the compiler back-end.
+ semantics of all the languages used in the compiler.
It defines a type [mem] of memory states, the following 4 basic
operations over memory states, and their properties:
-- [alloc]: allocate a fresh memory block;
-- [free]: invalidate a memory block;
- [load]: read a memory chunk at a given address;
-- [store]: store a memory chunk at a given address.
+- [store]: store a memory chunk at a given address;
+- [alloc]: allocate a fresh memory block;
+- [free]: invalidate a memory block.
*)
Require Import Coqlib.
@@ -15,12 +15,6 @@ Require Import Integers.
Require Import Floats.
Require Import Values.
-(** * Structure of memory states *)
-
-(** A memory state is organized in several disjoint blocks. Each block
- has a low and a high bound that defines its size. Each block map
- byte offsets to the contents of this byte. *)
-
Definition update (A: Set) (x: Z) (v: A) (f: Z -> A) : Z -> A :=
fun y => if zeq y x then v else f y.
@@ -40,32 +34,32 @@ Proof.
intros; unfold update. apply zeq_false; auto.
Qed.
+(** * Structure of memory states *)
+
+(** A memory state is organized in several disjoint blocks. Each block
+ has a low and a high bound that defines its size. Each block map
+ byte offsets to the contents of this byte. *)
+
(** The possible contents of a byte-sized memory cell. To give intuitions,
a 4-byte value [v] stored at offset [d] will be represented by
- the content [Datum32 v] at offset [d] and [Cont] at offsets [d+1],
+ the content [Datum(4, v)] at offset [d] and [Cont] at offsets [d+1],
[d+2] and [d+3]. The [Cont] contents enable detecting future writes
- that would overlap partially the 4-byte value. *)
+ that would partially overlap the 4-byte value. *)
Inductive content : Set :=
- | Undef: content (**r undefined contents *)
- | Datum8: val -> content (**r a value that fits in 1 byte *)
- | Datum16: val -> content (**r first byte of a 2-byte value *)
- | Datum32: val -> content (**r first byte of a 4-byte value *)
- | Datum64: val -> content (**r first byte of a 8-byte value *)
- | Cont: content. (**r continuation bytes for a multi-byte value *)
+ | Undef: content (**r undefined contents *)
+ | Datum: nat -> val -> content (**r first byte of a value *)
+ | Cont: content. (**r continuation bytes for a multi-byte value *)
Definition contentmap : Set := Z -> content.
(** A memory block comprises the dimensions of the block (low and high bounds)
- plus a mapping from byte offsets to contents. For technical reasons,
- we also carry around a proof that the mapping is equal to [Undef]
- outside the range of allowed byte offsets. *)
+ plus a mapping from byte offsets to contents. *)
Record block_contents : Set := mkblock {
low: Z;
high: Z;
- contents: contentmap;
- undef_outside: forall ofs, ofs < low \/ ofs >= high -> contents ofs = Undef
+ contents: contentmap
}.
(** A memory state is a mapping from block addresses (represented by [Z]
@@ -82,49 +76,43 @@ Record mem : Set := mkmem {
(** Memory reads and writes are performed by quantities called memory chunks,
encoding the type, size and signedness of the chunk being addressed.
- It is useful to extract only the size information as given by the
- following [memory_size] type. *)
-
-Inductive memory_size : Set :=
- | Size8: memory_size
- | Size16: memory_size
- | Size32: memory_size
- | Size64: memory_size.
-
-Definition size_mem (sz: memory_size) :=
- match sz with
- | Size8 => 1
- | Size16 => 2
- | Size32 => 4
- | Size64 => 8
+ The following functions extract the size information from a chunk. *)
+
+Definition size_chunk (chunk: memory_chunk) : Z :=
+ match chunk with
+ | Mint8signed => 1
+ | Mint8unsigned => 1
+ | Mint16signed => 2
+ | Mint16unsigned => 2
+ | Mint32 => 4
+ | Mfloat32 => 4
+ | Mfloat64 => 8
end.
-Definition mem_chunk (chunk: memory_chunk) :=
+Definition pred_size_chunk (chunk: memory_chunk) : nat :=
match chunk with
- | Mint8signed => Size8
- | Mint8unsigned => Size8
- | Mint16signed => Size16
- | Mint16unsigned => Size16
- | Mint32 => Size32
- | Mfloat32 => Size32
- | Mfloat64 => Size64
+ | Mint8signed => 0%nat
+ | Mint8unsigned => 0%nat
+ | Mint16signed => 1%nat
+ | Mint16unsigned => 1%nat
+ | Mint32 => 3%nat
+ | Mfloat32 => 3%nat
+ | Mfloat64 => 7%nat
end.
-Definition size_chunk (chunk: memory_chunk) := size_mem (mem_chunk chunk).
+Lemma size_chunk_pred:
+ forall chunk, size_chunk chunk = 1 + Z_of_nat (pred_size_chunk chunk).
+Proof.
+ destruct chunk; auto.
+Qed.
(** The initial store. *)
Remark one_pos: 1 > 0.
Proof. omega. Qed.
-Remark undef_undef_outside:
- forall lo hi ofs, ofs < lo \/ ofs >= hi -> (fun y => Undef) ofs = Undef.
-Proof.
- auto.
-Qed.
-
Definition empty_block (lo hi: Z) : block_contents :=
- mkblock lo hi (fun y => Undef) (undef_undef_outside lo hi).
+ mkblock lo hi (fun y => Undef).
Definition empty: mem :=
mkmem (fun x => empty_block 0 0) 1 one_pos.
@@ -200,8 +188,16 @@ Fixpoint check_cont (n: nat) (p: Z) (m: contentmap) {struct n} : bool :=
end
end.
-Definition getN (n: nat) (p: Z) (m: contentmap) : content :=
- if check_cont n (p + 1) m then m p else Undef.
+Definition eq_nat: forall (p q: nat), {p=q} + {p<>q}.
+Proof. decide equality. Defined.
+
+Definition getN (n: nat) (p: Z) (m: contentmap) : val :=
+ match m p with
+ | Datum n' v =>
+ if eq_nat n n' && check_cont n (p + 1) m then v else Vundef
+ | _ =>
+ Vundef
+ end.
Fixpoint set_cont (n: nat) (p: Z) (m: contentmap) {struct n} : contentmap :=
match n with
@@ -209,54 +205,47 @@ Fixpoint set_cont (n: nat) (p: Z) (m: contentmap) {struct n} : contentmap :=
| S n1 => update p Cont (set_cont n1 (p + 1) m)
end.
-Definition setN (n: nat) (p: Z) (v: content) (m: contentmap) : contentmap :=
- update p v (set_cont n (p + 1) m).
+Definition setN (n: nat) (p: Z) (v: val) (m: contentmap) : contentmap :=
+ update p (Datum n v) (set_cont n (p + 1) m).
-Lemma check_cont_true:
- forall n p m,
- (forall q, p <= q < p + Z_of_nat n -> m q = Cont) ->
- check_cont n p m = true.
+Lemma check_cont_spec:
+ forall n m p,
+ if check_cont n p m
+ then (forall q, p <= q < p + Z_of_nat n -> m q = Cont)
+ else (exists q, p <= q < p + Z_of_nat n /\ m q <> Cont).
Proof.
induction n; intros.
- reflexivity.
- simpl. rewrite H. apply IHn.
- intros. apply H. rewrite inj_S. omega.
- rewrite inj_S. omega.
+ simpl. intros; omegaContradiction.
+ simpl check_cont. repeat rewrite inj_S. caseEq (m p); intros.
+ exists p; split. omega. congruence.
+ exists p; split. omega. congruence.
+ generalize (IHn m (p + 1)). case (check_cont n (p + 1) m).
+ intros. assert (p = q \/ p + 1 <= q < p + Zsucc (Z_of_nat n)) by omega.
+ elim H2; intro. congruence. apply H0; omega.
+ intros [q [A B]]. exists q; split. omega. auto.
Qed.
-Hint Resolve check_cont_true.
-
-Lemma check_cont_inv:
- forall n p m,
- check_cont n p m = true ->
- (forall q, p <= q < p + Z_of_nat n -> m q = Cont).
+Lemma check_cont_true:
+ forall n m p,
+ (forall q, p <= q < p + Z_of_nat n -> m q = Cont) ->
+ check_cont n p m = true.
Proof.
- induction n; intros until m.
- unfold Z_of_nat. intros. omegaContradiction.
- unfold check_cont; fold check_cont.
- caseEq (m p); intros; try discriminate.
- assert (p = q \/ p + 1 <= q < (p + 1) + Z_of_nat n).
- rewrite inj_S in H1. omega.
- elim H2; intro.
- subst q. auto.
- apply IHn with (p + 1); auto.
+ intros. generalize (check_cont_spec n m p).
+ destruct (check_cont n p m). auto.
+ intros [q [A B]]. elim B; auto.
Qed.
-Hint Resolve check_cont_inv.
-
Lemma check_cont_false:
- forall n p q m,
- p <= q < p + Z_of_nat n ->
- m q <> Cont ->
+ forall n m p q,
+ p <= q < p + Z_of_nat n -> m q <> Cont ->
check_cont n p m = false.
Proof.
- intros. caseEq (check_cont n p m); intro.
- generalize (check_cont_inv _ _ _ H1 q H). intro. contradiction.
+ intros. generalize (check_cont_spec n m p).
+ destruct (check_cont n p m).
+ intros. elim H0; auto.
auto.
Qed.
-Hint Resolve check_cont_false.
-
Lemma set_cont_inside:
forall n p m q,
p <= q < p + Z_of_nat n ->
@@ -273,8 +262,6 @@ Proof.
red; intro; subst q. omega.
Qed.
-Hint Resolve set_cont_inside.
-
Lemma set_cont_outside:
forall n p m q,
q < p \/ p + Z_of_nat n <= q ->
@@ -286,160 +273,133 @@ Proof.
rewrite update_o. apply IHn. omega. omega.
Qed.
-Hint Resolve set_cont_outside.
-
Lemma getN_setN_same:
forall n p v m,
getN n p (setN n p v m) = v.
Proof.
- intros. unfold getN, setN.
- rewrite check_cont_true. apply update_s.
+ intros. unfold getN, setN. rewrite update_s.
+ rewrite check_cont_true. unfold proj_sumbool.
+ rewrite dec_eq_true. auto.
intros. rewrite update_o. apply set_cont_inside. auto.
omega.
Qed.
-Hint Resolve getN_setN_same.
-
Lemma getN_setN_other:
forall n1 n2 p1 p2 v m,
p1 + Z_of_nat n1 < p2 \/ p2 + Z_of_nat n2 < p1 ->
getN n2 p2 (setN n1 p1 v m) = getN n2 p2 m.
Proof.
intros. unfold getN, setN.
- caseEq (check_cont n2 (p2 + 1) m); intro.
- rewrite check_cont_true. rewrite update_o.
- apply set_cont_outside. omega. omega.
- intros. rewrite update_o. rewrite set_cont_outside.
- eapply check_cont_inv. eauto. auto.
+ generalize (check_cont_spec n2 m (p2 + 1));
+ destruct (check_cont n2 (p2 + 1) m); intros.
+ rewrite check_cont_true.
+ rewrite update_o. rewrite set_cont_outside. auto.
omega. omega.
- caseEq (check_cont n2 (p2 + 1) (update p1 v (set_cont n1 (p1 + 1) m))); intros.
- assert (check_cont n2 (p2 + 1) m = true).
- apply check_cont_true. intros.
- generalize (check_cont_inv _ _ _ H1 q H2).
- rewrite update_o. rewrite set_cont_outside. auto. omega. omega.
- rewrite H0 in H2; discriminate.
- auto.
-Qed.
-
-Hint Resolve getN_setN_other.
+ intros. rewrite update_o. rewrite set_cont_outside. auto.
+ omega. omega.
+ destruct H0 as [q [A B]].
+ rewrite (check_cont_false n2 (update p1 (Datum n1 v) (set_cont n1 (p1 + 1) m)) (p2 + 1) q).
+ rewrite update_o. rewrite set_cont_outside. auto.
+ omega. omega. omega.
+ rewrite update_o. rewrite set_cont_outside. auto.
+ omega. omega.
+Qed.
Lemma getN_setN_overlap:
forall n1 n2 p1 p2 v m,
p1 <> p2 ->
p1 + Z_of_nat n1 >= p2 -> p2 + Z_of_nat n2 >= p1 ->
- v <> Cont ->
- getN n2 p2 (setN n1 p1 v m) = Cont \/
- getN n2 p2 (setN n1 p1 v m) = Undef.
-Proof.
- intros. unfold getN.
- caseEq (check_cont n2 (p2 + 1) (setN n1 p1 v m)); intro.
- case (zlt p2 p1); intro.
- assert (p2 + 1 <= p1 < p2 + 1 + Z_of_nat n2). omega.
- generalize (check_cont_inv _ _ _ H3 p1 H4).
- unfold setN. rewrite update_s. intro. contradiction.
- left. unfold setN. rewrite update_o.
- apply set_cont_inside. omega. auto.
- right; auto.
-Qed.
-
-Hint Resolve getN_setN_overlap.
+ getN n2 p2 (setN n1 p1 v m) = Vundef.
+Proof.
+ intros. unfold getN, setN.
+ rewrite update_o; auto.
+ destruct (zlt p2 p1).
+ (* [p1] belongs to [[p2, p2 + n2 - 1]],
+ therefore [check_cont n2 (p2 + 1) ...] is false. *)
+ rewrite (check_cont_false n2 (update p1 (Datum n1 v) (set_cont n1 (p1 + 1) m)) (p2 + 1) p1).
+ destruct (set_cont n1 (p1 + 1) m p2); auto.
+ destruct (eq_nat n2 n); auto.
+ omega.
+ rewrite update_s. congruence.
+ (* [p2] belongs to [[p1 + 1, p1 + n1 - 1]],
+ therefore [set_cont n1 (p1 + 1) m p2] is [Cont]. *)
+ rewrite set_cont_inside. auto. omega.
+Qed.
Lemma getN_setN_mismatch:
forall n1 n2 p v m,
- getN n2 p (setN n1 p v m) = v \/ getN n2 p (setN n1 p v m) = Undef.
+ n1 <> n2 ->
+ getN n2 p (setN n1 p v m) = Vundef.
Proof.
- intros. unfold getN.
- caseEq (check_cont n2 (p + 1) (setN n1 p v m)); intro.
- left. unfold setN. apply update_s.
- right. auto.
+ intros. unfold getN, setN. rewrite update_s.
+ unfold proj_sumbool; rewrite dec_eq_false; simpl. auto. auto.
Qed.
-Hint Resolve getN_setN_mismatch.
+Lemma getN_setN_characterization:
+ forall m v n1 p1 n2 p2,
+ getN n2 p2 (setN n1 p1 v m) = v
+ \/ getN n2 p2 (setN n1 p1 v m) = getN n2 p2 m
+ \/ getN n2 p2 (setN n1 p1 v m) = Vundef.
+Proof.
+ intros. destruct (zeq p1 p2). subst p2.
+ destruct (eq_nat n1 n2). subst n2.
+ left; apply getN_setN_same.
+ right; right; apply getN_setN_mismatch; auto.
+ destruct (zlt (p1 + Z_of_nat n1) p2).
+ right; left; apply getN_setN_other; auto.
+ destruct (zlt (p2 + Z_of_nat n2) p1).
+ right; left; apply getN_setN_other; auto.
+ right; right; apply getN_setN_overlap; omega.
+Qed.
Lemma getN_init:
forall n p,
- getN n p (fun y => Undef) = Undef.
+ getN n p (fun y => Undef) = Vundef.
Proof.
- intros. unfold getN.
- case (check_cont n (p + 1) (fun y => Undef)); auto.
+ intros. auto.
Qed.
-Hint Resolve getN_init.
+(** [valid_access m chunk b ofs] holds if a memory access (load or store)
+ of the given chunk is possible in [m] at address [b, ofs]. *)
+
+Inductive valid_access (m: mem) (chunk: memory_chunk) (b: block) (ofs: Z) : Prop :=
+ | valid_access_intro:
+ valid_block m b ->
+ low_bound m b <= ofs ->
+ ofs + size_chunk chunk <= high_bound m b ->
+ valid_access m chunk b ofs.
(** The following function checks whether accessing the given memory chunk
at the given offset in the given block respects the bounds of the block. *)
-Definition in_bounds (chunk: memory_chunk) (ofs: Z) (c: block_contents) :
- {c.(low) <= ofs /\ ofs + size_chunk chunk <= c.(high)}
- + {c.(low) > ofs \/ ofs + size_chunk chunk > c.(high)} :=
- match zle c.(low) ofs, zle (ofs + size_chunk chunk) c.(high) with
- | left P1, left P2 => left _ (conj P1 P2)
- | left P1, right P2 => right _ (or_intror _ P2)
- | right P1, _ => right _ (or_introl _ P1)
- end.
-
-Lemma in_bounds_holds:
- forall (chunk: memory_chunk) (ofs: Z) (c: block_contents)
- (A: Set) (a b: A),
- c.(low) <= ofs -> ofs + size_chunk chunk <= c.(high) ->
- (if in_bounds chunk ofs c then a else b) = a.
+Definition in_bounds (m: mem) (chunk: memory_chunk) (b: block) (ofs: Z) :
+ {valid_access m chunk b ofs} + {~valid_access m chunk b ofs}.
Proof.
- intros. case (in_bounds chunk ofs c); intro.
- auto.
- omegaContradiction.
-Qed.
+ intros.
+ destruct (zlt b m.(nextblock)).
+ destruct (zle (low_bound m b) ofs).
+ destruct (zle (ofs + size_chunk chunk) (high_bound m b)).
+ left; constructor; auto.
+ right; red; intro V; inv V; omega.
+ right; red; intro V; inv V; omega.
+ right; red; intro V; inv V; contradiction.
+Defined.
-Lemma in_bounds_exten:
- forall (chunk: memory_chunk) (ofs: Z) (c: block_contents) (x: contentmap) P,
- in_bounds chunk ofs (mkblock (low c) (high c) x P) =
- in_bounds chunk ofs c.
+Lemma in_bounds_true:
+ forall m chunk b ofs (A: Set) (a1 a2: A),
+ valid_access m chunk b ofs ->
+ (if in_bounds m chunk b ofs then a1 else a2) = a1.
Proof.
- intros; reflexivity.
+ intros. destruct (in_bounds m chunk b ofs). auto. contradiction.
Qed.
-Hint Resolve in_bounds_holds in_bounds_exten.
-
(** [valid_pointer] holds if the given block address is valid and the
given offset falls within the bounds of the corresponding block. *)
Definition valid_pointer (m: mem) (b: block) (ofs: Z) : bool :=
- if zlt b m.(nextblock) then
- (let c := m.(blocks) b in
- if zle c.(low) ofs then if zlt ofs c.(high) then true else false
- else false)
- else false.
-
-(** Read a quantity of size [sz] at offset [ofs] in block contents [c].
- Return [Vundef] if the requested size does not match that of the
- current contents, or if the following offsets do not contain [Cont].
- The first check captures a size mismatch between the read and the
- latest write at this offset. The second check captures partial overwriting
- of the latest write at this offset by a more recent write at a nearby
- offset. *)
-
-Definition load_contents (sz: memory_size) (c: contentmap) (ofs: Z) : val :=
- match sz with
- | Size8 =>
- match getN 0%nat ofs c with
- | Datum8 n => n
- | _ => Vundef
- end
- | Size16 =>
- match getN 1%nat ofs c with
- | Datum16 n => n
- | _ => Vundef
- end
- | Size32 =>
- match getN 3%nat ofs c with
- | Datum32 n => n
- | _ => Vundef
- end
- | Size64 =>
- match getN 7%nat ofs c with
- | Datum64 n => n
- | _ => Vundef
- end
- end.
+ zlt b m.(nextblock) &&
+ zle (low_bound m b) ofs &&
+ zlt ofs (high_bound m b).
(** [load chunk m b ofs] perform a read in memory state [m], at address
[b] and offset [ofs]. [None] is returned if the address is invalid
@@ -447,15 +407,25 @@ Definition load_contents (sz: memory_size) (c: contentmap) (ofs: Z) : val :=
Definition load (chunk: memory_chunk) (m: mem) (b: block) (ofs: Z)
: option val :=
- if zlt b m.(nextblock) then
- (let c := m.(blocks) b in
- if in_bounds chunk ofs c
- then Some (Val.load_result chunk
- (load_contents (mem_chunk chunk) c.(contents) ofs))
- else None)
+ if in_bounds m chunk b ofs then
+ Some (Val.load_result chunk
+ (getN (pred_size_chunk chunk) ofs (contents (blocks m b))))
else
None.
+Lemma load_inv:
+ forall chunk m b ofs v,
+ load chunk m b ofs = Some v ->
+ valid_access m chunk b ofs /\
+ v = Val.load_result chunk
+ (getN (pred_size_chunk chunk) ofs (contents (blocks m b))).
+Proof.
+ intros until v; unfold load.
+ destruct (in_bounds m chunk b ofs); intros.
+ split. auto. congruence.
+ congruence.
+Qed.
+
(** [loadv chunk m addr] is similar, but the address and offset are given
as a single value [addr], which must be a pointer value. *)
@@ -465,90 +435,17 @@ Definition loadv (chunk: memory_chunk) (m: mem) (addr: val) : option val :=
| _ => None
end.
-Theorem load_in_bounds:
- forall (chunk: memory_chunk) (m: mem) (b: block) (ofs: Z),
- valid_block m b ->
- low_bound m b <= ofs ->
- ofs + size_chunk chunk <= high_bound m b ->
- exists v, load chunk m b ofs = Some v.
-Proof.
- intros. unfold load. rewrite zlt_true; auto.
- rewrite in_bounds_holds.
- exists (Val.load_result chunk
- (load_contents (mem_chunk chunk)
- (contents (m.(blocks) b))
- ofs)).
- auto.
- exact H0. exact H1.
-Qed.
-
-Lemma load_inv:
- forall (chunk: memory_chunk) (m: mem) (b: block) (ofs: Z) (v: val),
- load chunk m b ofs = Some v ->
- let c := m.(blocks) b in
- b < m.(nextblock) /\
- c.(low) <= ofs /\
- ofs + size_chunk chunk <= c.(high) /\
- Val.load_result chunk (load_contents (mem_chunk chunk) c.(contents) ofs) = v.
-Proof.
- intros until v; unfold load.
- case (zlt b (nextblock m)); intro.
- set (c := m.(blocks) b).
- case (in_bounds chunk ofs c).
- intuition congruence.
- intros; discriminate.
- intros; discriminate.
-Qed.
-Hint Resolve load_in_bounds load_inv.
-
-(* Write the value [v] with size [sz] at offset [ofs] in block contents [c].
- Return updated block contents. [Cont] contents are stored at the following
- offsets. *)
-
-Definition store_contents (sz: memory_size) (c: contentmap)
- (ofs: Z) (v: val) : contentmap :=
- match sz with
- | Size8 =>
- setN 0%nat ofs (Datum8 v) c
- | Size16 =>
- setN 1%nat ofs (Datum16 v) c
- | Size32 =>
- setN 3%nat ofs (Datum32 v) c
- | Size64 =>
- setN 7%nat ofs (Datum64 v) c
- end.
-
-Remark store_contents_undef_outside:
- forall sz c ofs v lo hi,
- lo <= ofs /\ ofs + size_mem sz <= hi ->
- (forall x, x < lo \/ x >= hi -> c x = Undef) ->
- (forall x, x < lo \/ x >= hi ->
- store_contents sz c ofs v x = Undef).
-Proof.
- intros until hi; intros [LO HI] UO.
- assert (forall n d x,
- ofs + (1 + Z_of_nat n) <= hi ->
- x < lo \/ x >= hi ->
- setN n ofs d c x = Undef).
- intros. unfold setN. rewrite update_o.
- transitivity (c x). apply set_cont_outside. omega.
- apply UO. omega. omega.
- unfold store_contents; destruct sz; unfold size_mem in HI;
- intros; apply H; auto; simpl Z_of_nat; auto.
-Qed.
+(* The memory state [m] after a store of value [v] at offset [ofs]
+ in block [b]. *)
Definition unchecked_store
(chunk: memory_chunk) (m: mem) (b: block)
- (ofs: Z) (v: val)
- (P: (m.(blocks) b).(low) <= ofs /\
- ofs + size_chunk chunk <= (m.(blocks) b).(high)) : mem :=
+ (ofs: Z) (v: val) : mem :=
let c := m.(blocks) b in
mkmem
(update b
(mkblock c.(low) c.(high)
- (store_contents (mem_chunk chunk) c.(contents) ofs v)
- (store_contents_undef_outside (mem_chunk chunk) c.(contents)
- ofs v _ _ P c.(undef_outside)))
+ (setN (pred_size_chunk chunk) ofs v c.(contents)))
m.(blocks))
m.(nextblock)
m.(nextblock_pos).
@@ -560,13 +457,21 @@ Definition unchecked_store
Definition store (chunk: memory_chunk) (m: mem) (b: block)
(ofs: Z) (v: val) : option mem :=
- if zlt b m.(nextblock) then
- match in_bounds chunk ofs (m.(blocks) b) with
- | left P => Some(unchecked_store chunk m b ofs v P)
- | right _ => None
- end
- else
- None.
+ if in_bounds m chunk b ofs
+ then Some(unchecked_store chunk m b ofs v)
+ else None.
+
+Lemma store_inv:
+ forall chunk m b ofs v m',
+ store chunk m b ofs v = Some m' ->
+ valid_access m chunk b ofs /\
+ m' = unchecked_store chunk m b ofs v.
+Proof.
+ intros until m'; unfold store.
+ destruct (in_bounds m chunk b ofs); intros.
+ split. auto. congruence.
+ congruence.
+Qed.
(** [storev chunk m addr v] is similar, but the address and offset are given
as a single value [addr], which must be a pointer value. *)
@@ -577,63 +482,21 @@ Definition storev (chunk: memory_chunk) (m: mem) (addr v: val) : option mem :=
| _ => None
end.
-Theorem store_in_bounds:
- forall (chunk: memory_chunk) (m: mem) (b: block) (ofs: Z) (v: val),
- valid_block m b ->
- low_bound m b <= ofs ->
- ofs + size_chunk chunk <= high_bound m b ->
- exists m', store chunk m b ofs v = Some m'.
-Proof.
- intros. unfold store.
- rewrite zlt_true; auto.
- case (in_bounds chunk ofs (blocks m b)); intro P.
- exists (unchecked_store chunk m b ofs v P). reflexivity.
- unfold low_bound in H0. unfold high_bound in H1. omegaContradiction.
-Qed.
-
-Lemma store_inv:
- forall (chunk: memory_chunk) (m m': mem) (b: block) (ofs: Z) (v: val),
- store chunk m b ofs v = Some m' ->
- let c := m.(blocks) b in
- b < m.(nextblock) /\
- c.(low) <= ofs /\
- ofs + size_chunk chunk <= c.(high) /\
- m'.(nextblock) = m.(nextblock) /\
- exists P, m'.(blocks) =
- update b (mkblock c.(low) c.(high)
- (store_contents (mem_chunk chunk) c.(contents) ofs v) P)
- m.(blocks).
-Proof.
- intros until v; unfold store.
- case (zlt b (nextblock m)); intro.
- set (c := m.(blocks) b).
- case (in_bounds chunk ofs c).
- intros; injection H; intro; subst m'. simpl.
- intuition. fold c.
- exists (store_contents_undef_outside (mem_chunk chunk)
- (contents c) ofs v (low c) (high c) a (undef_outside c)).
- auto.
- intros; discriminate.
- intros; discriminate.
-Qed.
-
-Hint Resolve store_in_bounds store_inv.
-
(** Build a block filled with the given initialization data. *)
Fixpoint contents_init_data (pos: Z) (id: list init_data) {struct id}: contentmap :=
match id with
| nil => (fun y => Undef)
| Init_int8 n :: id' =>
- store_contents Size8 (contents_init_data (pos + 1) id') pos (Vint n)
+ setN 0%nat pos (Vint n) (contents_init_data (pos + 1) id')
| Init_int16 n :: id' =>
- store_contents Size16 (contents_init_data (pos + 2) id') pos (Vint n)
+ setN 1%nat pos (Vint n) (contents_init_data (pos + 1) id')
| Init_int32 n :: id' =>
- store_contents Size32 (contents_init_data (pos + 4) id') pos (Vint n)
+ setN 3%nat pos (Vint n) (contents_init_data (pos + 1) id')
| Init_float32 f :: id' =>
- store_contents Size32 (contents_init_data (pos + 4) id') pos (Vfloat f)
+ setN 3%nat pos (Vfloat f) (contents_init_data (pos + 1) id')
| Init_float64 f :: id' =>
- store_contents Size64 (contents_init_data (pos + 8) id') pos (Vfloat f)
+ setN 7%nat pos (Vfloat f) (contents_init_data (pos + 1) id')
| Init_space n :: id' =>
contents_init_data (pos + Zmax n 0) id'
| Init_pointer x :: id' =>
@@ -664,32 +527,8 @@ Proof.
generalize (Zmax2 z 0). omega. omega.
Qed.
-Remark contents_init_data_undef_outside:
- forall id pos x,
- x < pos \/ x >= pos + size_init_data_list id ->
- contents_init_data pos id x = Undef.
-Proof.
- induction id; simpl; intros.
- auto.
- generalize (size_init_data_list_pos id); intro.
- assert (forall n delta dt,
- delta = 1 + Z_of_nat n ->
- x < pos \/ x >= pos + (delta + size_init_data_list id) ->
- setN n pos dt (contents_init_data (pos + delta) id) x = Undef).
- intros. unfold setN. rewrite update_o.
- transitivity (contents_init_data (pos + delta) id x).
- apply set_cont_outside. omega.
- apply IHid. omega. omega.
- unfold size_init_data in H; destruct a;
- try (apply H1; [reflexivity|assumption]).
- apply IHid. generalize (Zmax2 z 0). omega.
- apply IHid. omega.
-Qed.
-
Definition block_init_data (id: list init_data) : block_contents :=
- mkblock 0 (size_init_data_list id)
- (contents_init_data 0 id)
- (contents_init_data_undef_outside id 0).
+ mkblock 0 (size_init_data_list id) (contents_init_data 0 id).
Definition alloc_init_data (m: mem) (id: list init_data) : mem * block :=
(mkmem (update m.(nextblock)
@@ -702,8 +541,7 @@ Definition alloc_init_data (m: mem) (id: list init_data) : mem * block :=
Remark block_init_data_empty:
block_init_data nil = empty_block 0 0.
Proof.
- unfold block_init_data, empty_block. simpl.
- decEq. apply proof_irrelevance.
+ auto.
Qed.
(** * Properties of the memory operations *)
@@ -716,573 +554,961 @@ Proof.
intros; red; intros. subst b'. contradiction.
Qed.
-Theorem fresh_block_alloc:
- forall (m1 m2: mem) (lo hi: Z) (b: block),
- alloc m1 lo hi = (m2, b) -> ~(valid_block m1 b).
+Lemma valid_access_valid_block:
+ forall m chunk b ofs,
+ valid_access m chunk b ofs -> valid_block m b.
Proof.
- intros. injection H; intros; subst b.
- unfold valid_block. omega.
+ intros. inv H; auto.
Qed.
-Theorem valid_new_block:
- forall (m1 m2: mem) (lo hi: Z) (b: block),
- alloc m1 lo hi = (m2, b) -> valid_block m2 b.
+Hint Resolve valid_not_valid_diff valid_access_valid_block: mem.
+
+(** ** Properties related to [load] *)
+
+Theorem valid_access_load:
+ forall m chunk b ofs,
+ valid_access m chunk b ofs ->
+ exists v, load chunk m b ofs = Some v.
Proof.
- unfold alloc, valid_block; intros.
- injection H; intros. subst b; subst m2; simpl. omega.
+ intros. econstructor. unfold load. rewrite in_bounds_true; auto.
Qed.
-Theorem valid_block_alloc:
- forall (m1 m2: mem) (lo hi: Z) (b b': block),
- alloc m1 lo hi = (m2, b') ->
- valid_block m1 b -> valid_block m2 b.
+Theorem load_valid_access:
+ forall m chunk b ofs v,
+ load chunk m b ofs = Some v ->
+ valid_access m chunk b ofs.
Proof.
- unfold alloc, valid_block; intros.
- injection H; intros. subst m2; simpl. omega.
+ intros. generalize (load_inv _ _ _ _ _ H). tauto.
Qed.
-Theorem valid_block_store:
- forall (chunk: memory_chunk) (m1 m2: mem) (b b': block) (ofs: Z) (v: val),
- store chunk m1 b' ofs v = Some m2 ->
- valid_block m1 b -> valid_block m2 b.
+Hint Resolve load_valid_access valid_access_load.
+
+(** ** Properties related to [store] *)
+
+Lemma valid_access_store:
+ forall m1 chunk b ofs v,
+ valid_access m1 chunk b ofs ->
+ exists m2, store chunk m1 b ofs v = Some m2.
Proof.
- intros. generalize (store_inv _ _ _ _ _ _ H).
- intros [A [B [C [D [P E]]]]].
- red. rewrite D. exact H0.
+ intros. econstructor. unfold store. rewrite in_bounds_true; auto.
Qed.
-Theorem valid_block_free:
- forall (m: mem) (b b': block),
- valid_block m b -> valid_block (free m b') b.
+Hint Resolve valid_access_store: mem.
+
+Section STORE.
+Variable chunk: memory_chunk.
+Variable m1: mem.
+Variable b: block.
+Variable ofs: Z.
+Variable v: val.
+Variable m2: mem.
+Hypothesis STORE: store chunk m1 b ofs v = Some m2.
+
+Lemma low_bound_store:
+ forall b', low_bound m2 b' = low_bound m1 b'.
Proof.
- unfold valid_block, free; intros.
- simpl. auto.
+ intro. elim (store_inv _ _ _ _ _ _ STORE); intros.
+ subst m2. unfold low_bound, unchecked_store; simpl.
+ unfold update. destruct (zeq b' b); auto. subst b'; auto.
+Qed.
+
+Lemma high_bound_store:
+ forall b', high_bound m2 b' = high_bound m1 b'.
+Proof.
+ intro. elim (store_inv _ _ _ _ _ _ STORE); intros.
+ subst m2. unfold high_bound, unchecked_store; simpl.
+ unfold update. destruct (zeq b' b); auto. subst b'; auto.
Qed.
-(** ** Properties related to [alloc] *)
+Lemma nextblock_store:
+ nextblock m2 = nextblock m1.
+Proof.
+ intros. elim (store_inv _ _ _ _ _ _ STORE); intros.
+ subst m2; reflexivity.
+Qed.
-Theorem load_alloc_other:
- forall (chunk: memory_chunk) (m1 m2: mem)
- (b b': block) (ofs lo hi: Z) (v: val),
- alloc m1 lo hi = (m2, b') ->
- load chunk m1 b ofs = Some v ->
- load chunk m2 b ofs = Some v.
+Lemma store_valid_block_1:
+ forall b', valid_block m1 b' -> valid_block m2 b'.
Proof.
- unfold alloc; intros.
- injection H; intros; subst m2; clear H.
- generalize (load_inv _ _ _ _ _ H0).
- intros (A, (B, (C, D))).
- unfold load; simpl.
- rewrite zlt_true.
- repeat (rewrite update_o).
- rewrite in_bounds_holds. congruence. auto. auto.
- omega. omega.
+ unfold valid_block; intros. rewrite nextblock_store; auto.
Qed.
-Lemma load_contents_init:
- forall (sz: memory_size) (ofs: Z),
- load_contents sz (fun y => Undef) ofs = Vundef.
+Lemma store_valid_block_2:
+ forall b', valid_block m2 b' -> valid_block m1 b'.
Proof.
- intros. destruct sz; reflexivity.
+ unfold valid_block; intros. rewrite nextblock_store in H; auto.
Qed.
-Theorem load_alloc_same:
- forall (chunk: memory_chunk) (m1 m2: mem)
- (b b': block) (ofs lo hi: Z) (v: val),
- alloc m1 lo hi = (m2, b') ->
- load chunk m2 b' ofs = Some v ->
- v = Vundef.
+Hint Resolve store_valid_block_1 store_valid_block_2: mem.
+
+Lemma store_valid_access_1:
+ forall chunk' b' ofs',
+ valid_access m1 chunk' b' ofs' -> valid_access m2 chunk' b' ofs'.
Proof.
- unfold alloc; intros.
- injection H; intros; subst m2; clear H.
- generalize (load_inv _ _ _ _ _ H0).
- simpl. rewrite H1. rewrite update_s. simpl. intros (A, (B, (C, D))).
- rewrite <- D. rewrite load_contents_init.
- destruct chunk; reflexivity.
-Qed.
+ intros. inv H. constructor. auto with mem.
+ rewrite low_bound_store; auto.
+ rewrite high_bound_store; auto.
+Qed.
-Theorem low_bound_alloc:
- forall (m1 m2: mem) (b b': block) (lo hi: Z),
- alloc m1 lo hi = (m2, b') ->
- low_bound m2 b = if zeq b b' then lo else low_bound m1 b.
+Lemma store_valid_access_2:
+ forall chunk' b' ofs',
+ valid_access m2 chunk' b' ofs' -> valid_access m1 chunk' b' ofs'.
Proof.
- unfold alloc; intros.
- injection H; intros; subst m2; clear H.
- unfold low_bound; simpl.
- unfold update.
- subst b'.
- case (zeq b (nextblock m1)); reflexivity.
+ intros. inv H. constructor. auto with mem.
+ rewrite low_bound_store in H1; auto.
+ rewrite high_bound_store in H2; auto.
Qed.
-Theorem high_bound_alloc:
- forall (m1 m2: mem) (b b': block) (lo hi: Z),
- alloc m1 lo hi = (m2, b') ->
- high_bound m2 b = if zeq b b' then hi else high_bound m1 b.
+Lemma store_valid_access_3:
+ valid_access m1 chunk b ofs.
Proof.
- unfold alloc; intros.
- injection H; intros; subst m2; clear H.
- unfold high_bound; simpl.
- unfold update.
- subst b'.
- case (zeq b (nextblock m1)); reflexivity.
+ elim (store_inv _ _ _ _ _ _ STORE); intros. auto.
Qed.
-Theorem store_alloc:
- forall (chunk: memory_chunk) (m1 m2: mem) (b: block) (ofs lo hi: Z) (v: val),
- alloc m1 lo hi = (m2, b) ->
- lo <= ofs -> ofs + size_chunk chunk <= hi ->
- exists m2', store chunk m2 b ofs v = Some m2'.
+Hint Resolve store_valid_access_1 store_valid_access_2
+ store_valid_access_3: mem.
+
+Theorem load_store_similar:
+ forall chunk',
+ size_chunk chunk' = size_chunk chunk ->
+ load chunk' m2 b ofs = Some (Val.load_result chunk' v).
Proof.
- unfold alloc; intros.
- injection H; intros.
- assert (A: b < m2.(nextblock)).
- subst m2; subst b; simpl; omega.
- assert (B: low_bound m2 b <= ofs).
- subst m2; subst b. unfold low_bound; simpl. rewrite update_s.
- simpl. assumption.
- assert (C: ofs + size_chunk chunk <= high_bound m2 b).
- subst m2; subst b. unfold high_bound; simpl. rewrite update_s.
- simpl. assumption.
- exact (store_in_bounds chunk m2 b ofs v A B C).
+ intros. destruct (store_inv _ _ _ _ _ _ STORE).
+ unfold load. rewrite in_bounds_true.
+ decEq. decEq. rewrite H1. unfold unchecked_store; simpl.
+ rewrite update_s. simpl.
+ replace (pred_size_chunk chunk) with (pred_size_chunk chunk').
+ apply getN_setN_same.
+ repeat rewrite size_chunk_pred in H. omega.
+ apply store_valid_access_1.
+ inv H0. constructor; auto. congruence.
Qed.
-Hint Resolve store_alloc high_bound_alloc low_bound_alloc load_alloc_same
-load_contents_init load_alloc_other.
+Theorem load_store_same:
+ load chunk m2 b ofs = Some (Val.load_result chunk v).
+Proof.
+ eapply load_store_similar; eauto.
+Qed.
+
+Theorem load_store_other:
+ forall chunk' b' ofs',
+ b' <> b
+ \/ ofs' + size_chunk chunk' <= ofs
+ \/ ofs + size_chunk chunk <= ofs' ->
+ load chunk' m2 b' ofs' = load chunk' m1 b' ofs'.
+Proof.
+ intros. destruct (store_inv _ _ _ _ _ _ STORE).
+ unfold load. destruct (in_bounds m1 chunk' b' ofs').
+ rewrite in_bounds_true. decEq. decEq.
+ rewrite H1; unfold unchecked_store; simpl.
+ unfold update. destruct (zeq b' b). subst b'.
+ simpl. repeat rewrite size_chunk_pred in H.
+ apply getN_setN_other. elim H; intro. congruence. omega.
+ auto.
+ eauto with mem.
+ destruct (in_bounds m2 chunk' b' ofs'); auto.
+ elim n. eauto with mem.
+Qed.
+
+Theorem load_store_overlap:
+ forall chunk' ofs' v',
+ load chunk' m2 b ofs' = Some v' ->
+ ofs' <> ofs ->
+ ofs' + size_chunk chunk' > ofs ->
+ ofs + size_chunk chunk > ofs' ->
+ v' = Vundef.
+Proof.
+ intros. destruct (store_inv _ _ _ _ _ _ STORE).
+ destruct (load_inv _ _ _ _ _ H). rewrite H6.
+ rewrite H4. unfold unchecked_store. simpl. rewrite update_s.
+ simpl. rewrite getN_setN_overlap.
+ destruct chunk'; reflexivity.
+ auto. rewrite size_chunk_pred in H2. omega.
+ rewrite size_chunk_pred in H1. omega.
+Qed.
+
+Theorem load_store_overlap':
+ forall chunk' ofs',
+ valid_access m1 chunk' b ofs' ->
+ ofs' <> ofs ->
+ ofs' + size_chunk chunk' > ofs ->
+ ofs + size_chunk chunk > ofs' ->
+ load chunk' m2 b ofs' = Some Vundef.
+Proof.
+ intros.
+ assert (exists v', load chunk' m2 b ofs' = Some v').
+ eauto with mem.
+ destruct H3 as [v' LOAD]. rewrite LOAD. decEq.
+ eapply load_store_overlap; eauto.
+Qed.
-(** ** Properties related to [free] *)
+Theorem load_store_mismatch:
+ forall chunk' v',
+ load chunk' m2 b ofs = Some v' ->
+ size_chunk chunk' <> size_chunk chunk ->
+ v' = Vundef.
+Proof.
+ intros. destruct (store_inv _ _ _ _ _ _ STORE).
+ destruct (load_inv _ _ _ _ _ H). rewrite H4.
+ rewrite H2. unfold unchecked_store. simpl. rewrite update_s.
+ simpl. rewrite getN_setN_mismatch.
+ destruct chunk'; reflexivity.
+ repeat rewrite size_chunk_pred in H0; omega.
+Qed.
-Theorem load_free:
- forall (chunk: memory_chunk) (m: mem) (b bf: block) (ofs: Z),
- b <> bf ->
- load chunk (free m bf) b ofs = load chunk m b ofs.
+Theorem load_store_mismatch':
+ forall chunk',
+ valid_access m1 chunk' b ofs ->
+ size_chunk chunk' <> size_chunk chunk ->
+ load chunk' m2 b ofs = Some Vundef.
Proof.
- intros. unfold free, load; simpl.
- case (zlt b (nextblock m)).
- repeat (rewrite update_o; auto).
- reflexivity.
+ intros.
+ assert (exists v', load chunk' m2 b ofs = Some v').
+ eauto with mem.
+ destruct H1 as [v' LOAD]. rewrite LOAD. decEq.
+ eapply load_store_mismatch; eauto.
+Qed.
+
+Inductive load_store_cases
+ (chunk1: memory_chunk) (b1: block) (ofs1: Z)
+ (chunk2: memory_chunk) (b2: block) (ofs2: Z) : Set :=
+ | lsc_similar:
+ b1 = b2 -> ofs1 = ofs2 -> size_chunk chunk1 = size_chunk chunk2 ->
+ load_store_cases chunk1 b1 ofs1 chunk2 b2 ofs2
+ | lsc_other:
+ b1 <> b2 \/ ofs2 + size_chunk chunk2 <= ofs1 \/ ofs1 + size_chunk chunk1 <= ofs2 ->
+ load_store_cases chunk1 b1 ofs1 chunk2 b2 ofs2
+ | lsc_overlap:
+ b1 = b2 -> ofs1 <> ofs2 -> ofs2 + size_chunk chunk2 > ofs1 -> ofs1 + size_chunk chunk1 > ofs2 ->
+ load_store_cases chunk1 b1 ofs1 chunk2 b2 ofs2
+ | lsc_mismatch:
+ b1 = b2 -> ofs1 = ofs2 -> size_chunk chunk1 <> size_chunk chunk2 ->
+ load_store_cases chunk1 b1 ofs1 chunk2 b2 ofs2.
+
+Remark size_chunk_pos:
+ forall chunk1, size_chunk chunk1 > 0.
+Proof.
+ destruct chunk1; simpl; omega.
+Qed.
+
+Definition load_store_classification:
+ forall (chunk1: memory_chunk) (b1: block) (ofs1: Z)
+ (chunk2: memory_chunk) (b2: block) (ofs2: Z),
+ load_store_cases chunk1 b1 ofs1 chunk2 b2 ofs2.
+Proof.
+ intros. destruct (eq_block b1 b2).
+ destruct (zeq ofs1 ofs2).
+ destruct (zeq (size_chunk chunk1) (size_chunk chunk2)).
+ apply lsc_similar; auto.
+ apply lsc_mismatch; auto.
+ destruct (zle (ofs2 + size_chunk chunk2) ofs1).
+ apply lsc_other. tauto.
+ destruct (zle (ofs1 + size_chunk chunk1) ofs2).
+ apply lsc_other. tauto.
+ apply lsc_overlap; auto.
+ apply lsc_other; tauto.
+Qed.
+
+Theorem load_store_characterization:
+ forall chunk' b' ofs',
+ valid_access m1 chunk' b' ofs' ->
+ load chunk' m2 b' ofs' =
+ match load_store_classification chunk b ofs chunk' b' ofs' with
+ | lsc_similar _ _ _ => Some (Val.load_result chunk' v)
+ | lsc_other _ => load chunk' m1 b' ofs'
+ | lsc_overlap _ _ _ _ => Some Vundef
+ | lsc_mismatch _ _ _ => Some Vundef
+ end.
+Proof.
+ intros.
+ assert (exists v', load chunk' m2 b' ofs' = Some v') by eauto with mem.
+ destruct H0 as [v' LOAD].
+ destruct (load_store_classification chunk b ofs chunk' b' ofs').
+ subst b' ofs'. apply load_store_similar; auto.
+ apply load_store_other; intuition.
+ subst b'. rewrite LOAD. decEq.
+ eapply load_store_overlap; eauto.
+ subst b' ofs'. rewrite LOAD. decEq.
+ eapply load_store_mismatch; eauto.
Qed.
-Theorem low_bound_free:
- forall (m: mem) (b bf: block),
- b <> bf ->
- low_bound (free m bf) b = low_bound m b.
+End STORE.
+
+Hint Resolve store_valid_block_1 store_valid_block_2: mem.
+Hint Resolve store_valid_access_1 store_valid_access_2
+ store_valid_access_3: mem.
+
+(** ** Properties related to [alloc]. *)
+
+Section ALLOC.
+
+Variable m1: mem.
+Variables lo hi: Z.
+Variable m2: mem.
+Variable b: block.
+Hypothesis ALLOC: alloc m1 lo hi = (m2, b).
+
+Lemma nextblock_alloc:
+ nextblock m2 = Zsucc (nextblock m1).
Proof.
- intros. unfold free, low_bound; simpl.
- rewrite update_o; auto.
+ injection ALLOC; intros. rewrite <- H0; auto.
Qed.
-Theorem high_bound_free:
- forall (m: mem) (b bf: block),
- b <> bf ->
- high_bound (free m bf) b = high_bound m b.
+Lemma alloc_result:
+ b = nextblock m1.
Proof.
- intros. unfold free, high_bound; simpl.
- rewrite update_o; auto.
+ injection ALLOC; auto.
Qed.
-Hint Resolve load_free low_bound_free high_bound_free.
-(** ** Properties related to [store] *)
+Lemma valid_block_alloc:
+ forall b', valid_block m1 b' -> valid_block m2 b'.
+Proof.
+ unfold valid_block; intros. rewrite nextblock_alloc. omega.
+Qed.
-Lemma store_is_in_bounds:
- forall chunk m1 b ofs v m2,
- store chunk m1 b ofs v = Some m2 ->
- low_bound m1 b <= ofs /\ ofs + size_chunk chunk <= high_bound m1 b.
+Lemma fresh_block_alloc:
+ ~(valid_block m1 b).
Proof.
- intros. generalize (store_inv _ _ _ _ _ _ H).
- intros [A [B [C [P D]]]].
- unfold low_bound, high_bound. tauto.
+ unfold valid_block. rewrite alloc_result. omega.
Qed.
-Lemma load_store_contents_same:
- forall (sz: memory_size) (c: contentmap) (ofs: Z) (v: val),
- load_contents sz (store_contents sz c ofs v) ofs = v.
+Lemma valid_new_block:
+ valid_block m2 b.
Proof.
- intros until v.
- unfold load_contents, store_contents in |- *; case sz;
- rewrite getN_setN_same; reflexivity.
+ unfold valid_block. rewrite alloc_result. rewrite nextblock_alloc. omega.
Qed.
-
-Theorem load_store_same:
- forall (chunk: memory_chunk) (m1 m2: mem) (b: block) (ofs: Z) (v: val),
- store chunk m1 b ofs v = Some m2 ->
- load chunk m2 b ofs = Some (Val.load_result chunk v).
+
+Hint Resolve valid_block_alloc fresh_block_alloc valid_new_block: mem.
+
+Lemma valid_block_alloc_inv:
+ forall b', valid_block m2 b' -> b' = b \/ valid_block m1 b'.
Proof.
- intros.
- generalize (store_inv _ _ _ _ _ _ H).
- intros (A, (B, (C, (D, (P, E))))).
- unfold load. rewrite D.
- rewrite zlt_true; auto. rewrite E.
- repeat (rewrite update_s). simpl.
- rewrite in_bounds_exten. rewrite in_bounds_holds; auto.
- rewrite load_store_contents_same; auto.
-Qed.
-
-Lemma load_store_contents_other:
- forall (sz1 sz2: memory_size) (c: contentmap)
- (ofs1 ofs2: Z) (v: val),
- ofs2 + size_mem sz2 <= ofs1 \/ ofs1 + size_mem sz1 <= ofs2 ->
- load_contents sz2 (store_contents sz1 c ofs1 v) ofs2 =
- load_contents sz2 c ofs2.
-Proof.
- intros until v.
- unfold size_mem, store_contents, load_contents;
- case sz1; case sz2; intros;
- (rewrite getN_setN_other;
- [reflexivity | simpl Z_of_nat; omega]).
+ unfold valid_block; intros.
+ rewrite nextblock_alloc in H. rewrite alloc_result.
+ unfold block; omega.
Qed.
-Theorem load_store_other:
- forall (chunk1 chunk2: memory_chunk) (m1 m2: mem)
- (b1 b2: block) (ofs1 ofs2: Z) (v: val),
- store chunk1 m1 b1 ofs1 v = Some m2 ->
- b1 <> b2
- \/ ofs2 + size_chunk chunk2 <= ofs1
- \/ ofs1 + size_chunk chunk1 <= ofs2 ->
- load chunk2 m2 b2 ofs2 = load chunk2 m1 b2 ofs2.
+Lemma low_bound_alloc:
+ forall b', low_bound m2 b' = if zeq b' b then lo else low_bound m1 b'.
Proof.
- intros.
- generalize (store_inv _ _ _ _ _ _ H).
- intros (A, (B, (C, (D, (P, E))))).
- unfold load. rewrite D.
- case (zlt b2 (nextblock m1)); intro.
- rewrite E; unfold update; case (zeq b2 b1); intro; simpl.
- subst b2. rewrite in_bounds_exten.
- rewrite load_store_contents_other. auto.
- tauto.
- reflexivity.
- reflexivity.
-Qed.
-
-Ltac LSCO :=
- match goal with
- | |- (match getN ?sz2 ?ofs2 (setN ?sz1 ?ofs1 ?v ?c) with
- | Undef => _
- | Datum8 _ => _
- | Datum16 _ => _
- | Datum32 _ => _
- | Datum64 _ => _
- | Cont => _
- end = _) =>
- elim (getN_setN_overlap sz1 sz2 ofs1 ofs2 v c);
- [ let H := fresh in (intro H; rewrite H; reflexivity)
- | let H := fresh in (intro H; rewrite H; reflexivity)
- | assumption
- | simpl Z_of_nat; omega
- | simpl Z_of_nat; omega
- | discriminate ]
- end.
+ intros. injection ALLOC; intros. rewrite <- H0; unfold low_bound; simpl.
+ unfold update. rewrite H. destruct (zeq b' b); auto.
+Qed.
-Lemma load_store_contents_overlap:
- forall (sz1 sz2: memory_size) (c: contentmap)
- (ofs1 ofs2: Z) (v: val),
- ofs1 <> ofs2 ->
- ofs2 + size_mem sz2 > ofs1 -> ofs1 + size_mem sz1 > ofs2 ->
- load_contents sz2 (store_contents sz1 c ofs1 v) ofs2 = Vundef.
+Lemma low_bound_alloc_same:
+ low_bound m2 b = lo.
Proof.
- intros.
- destruct sz1; destruct sz2; simpl in H0; simpl in H1; simpl; LSCO.
-Qed.
-
-Ltac LSCM :=
- match goal with
- | H:(?x <> ?x) |- _ =>
- elim H; reflexivity
- | |- (match getN ?sz2 ?ofs (setN ?sz1 ?ofs ?v ?c) with
- | Undef => _
- | Datum8 _ => _
- | Datum16 _ => _
- | Datum32 _ => _
- | Datum64 _ => _
- | Cont => _
- end = _) =>
- elim (getN_setN_mismatch sz1 sz2 ofs v c);
- [ let H := fresh in (intro H; rewrite H; reflexivity)
- | let H := fresh in (intro H; rewrite H; reflexivity) ]
- end.
+ rewrite low_bound_alloc. apply zeq_true.
+Qed.
-Lemma load_store_contents_mismatch:
- forall (sz1 sz2: memory_size) (c: contentmap)
- (ofs: Z) (v: val),
- sz1 <> sz2 ->
- load_contents sz2 (store_contents sz1 c ofs v) ofs = Vundef.
+Lemma low_bound_alloc_other:
+ forall b', valid_block m1 b' -> low_bound m2 b' = low_bound m1 b'.
Proof.
- intros.
- destruct sz1; destruct sz2; simpl; LSCM.
-Qed.
+ intros; rewrite low_bound_alloc.
+ apply zeq_false. eauto with mem.
+Qed.
-Theorem low_bound_store:
- forall (chunk: memory_chunk) (m1 m2: mem) (b b': block) (ofs: Z) (v: val),
- store chunk m1 b ofs v = Some m2 ->
- low_bound m2 b' = low_bound m1 b'.
+Lemma high_bound_alloc:
+ forall b', high_bound m2 b' = if zeq b' b then hi else high_bound m1 b'.
Proof.
- intros.
- generalize (store_inv _ _ _ _ _ _ H).
- intros (A, (B, (C, (D, (P, E))))).
- unfold low_bound. rewrite E; unfold update.
- case (zeq b' b); intro.
- subst b'. reflexivity.
- reflexivity.
+ intros. injection ALLOC; intros. rewrite <- H0; unfold high_bound; simpl.
+ unfold update. rewrite H. destruct (zeq b' b); auto.
Qed.
-Theorem high_bound_store:
- forall (chunk: memory_chunk) (m1 m2: mem) (b b': block) (ofs: Z) (v: val),
- store chunk m1 b ofs v = Some m2 ->
- high_bound m2 b' = high_bound m1 b'.
+Lemma high_bound_alloc_same:
+ high_bound m2 b = hi.
Proof.
- intros.
- generalize (store_inv _ _ _ _ _ _ H).
- intros (A, (B, (C, (D, (P, E))))).
- unfold high_bound. rewrite E; unfold update.
- case (zeq b' b); intro.
- subst b'. reflexivity.
- reflexivity.
+ rewrite high_bound_alloc. apply zeq_true.
Qed.
-Hint Resolve high_bound_store low_bound_store load_store_contents_mismatch
- load_store_contents_overlap load_store_other store_is_in_bounds
- load_store_contents_same load_store_same load_store_contents_other.
+Lemma high_bound_alloc_other:
+ forall b', valid_block m1 b' -> high_bound m2 b' = high_bound m1 b'.
+Proof.
+ intros; rewrite high_bound_alloc.
+ apply zeq_false. eauto with mem.
+Qed.
-(** * Agreement between memory blocks. *)
+Lemma valid_access_alloc_other:
+ forall chunk b' ofs,
+ valid_access m1 chunk b' ofs ->
+ valid_access m2 chunk b' ofs.
+Proof.
+ intros. inv H. constructor. auto with mem.
+ rewrite low_bound_alloc_other; auto.
+ rewrite high_bound_alloc_other; auto.
+Qed.
-(** Two memory blocks [c1] and [c2] agree on a range [lo] to [hi]
- if they associate the same contents to byte offsets in the range
- [lo] (included) to [hi] (excluded). *)
+Lemma valid_access_alloc_same:
+ forall chunk ofs,
+ lo <= ofs -> ofs + size_chunk chunk <= hi ->
+ valid_access m2 chunk b ofs.
+Proof.
+ intros. constructor. auto with mem.
+ rewrite low_bound_alloc_same; auto.
+ rewrite high_bound_alloc_same; auto.
+Qed.
+
+Hint Resolve valid_access_alloc_other valid_access_alloc_same: mem.
+
+Lemma valid_access_alloc_inv:
+ forall chunk b' ofs,
+ valid_access m2 chunk b' ofs ->
+ valid_access m1 chunk b' ofs \/
+ (b' = b /\ lo <= ofs /\ ofs + size_chunk chunk <= hi).
+Proof.
+ intros. inv H.
+ elim (valid_block_alloc_inv _ H0); intro.
+ subst b'. rewrite low_bound_alloc_same in H1.
+ rewrite high_bound_alloc_same in H2.
+ right. tauto.
+ left. constructor. auto.
+ rewrite low_bound_alloc_other in H1; auto.
+ rewrite high_bound_alloc_other in H2; auto.
+Qed.
+
+Theorem load_alloc_unchanged:
+ forall chunk b' ofs,
+ valid_block m1 b' ->
+ load chunk m2 b' ofs = load chunk m1 b' ofs.
+Proof.
+ intros. unfold load.
+ destruct (in_bounds m2 chunk b' ofs).
+ elim (valid_access_alloc_inv _ _ _ v). intro.
+ rewrite in_bounds_true; auto.
+ injection ALLOC; intros. rewrite <- H2; simpl.
+ rewrite update_o. auto. rewrite H1. apply sym_not_equal. eauto with mem.
+ intros [A [B C]]. subst b'. elimtype False. eauto with mem.
+ destruct (in_bounds m1 chunk b' ofs).
+ elim n; eauto with mem.
+ auto.
+Qed.
-Definition contentmap_agree (lo hi: Z) (c1 c2: contentmap) :=
- forall (ofs: Z),
- lo <= ofs < hi -> c1 ofs = c2 ofs.
+Theorem load_alloc_other:
+ forall chunk b' ofs v,
+ load chunk m1 b' ofs = Some v ->
+ load chunk m2 b' ofs = Some v.
+Proof.
+ intros. rewrite <- H. apply load_alloc_unchanged. eauto with mem.
+Qed.
-Definition block_contents_agree (lo hi: Z) (c1 c2: block_contents) :=
- contentmap_agree lo hi c1.(contents) c2.(contents).
+Theorem load_alloc_same:
+ forall chunk ofs v,
+ load chunk m2 b ofs = Some v ->
+ v = Vundef.
+Proof.
+ intros. destruct (load_inv _ _ _ _ _ H). rewrite H1.
+ injection ALLOC; intros. rewrite <- H3; simpl.
+ rewrite <- H2. rewrite update_s.
+ simpl. rewrite getN_init. destruct chunk; auto.
+Qed.
+
+Theorem load_alloc_same':
+ forall chunk ofs,
+ lo <= ofs -> ofs + size_chunk chunk <= hi ->
+ load chunk m2 b ofs = Some Vundef.
+Proof.
+ intros. assert (exists v, load chunk m2 b ofs = Some v).
+ apply valid_access_load. constructor; eauto with mem.
+ rewrite low_bound_alloc_same. auto.
+ rewrite high_bound_alloc_same. auto.
+ destruct H1 as [v LOAD]. rewrite LOAD. decEq.
+ eapply load_alloc_same; eauto.
+Qed.
+
+End ALLOC.
+
+Hint Resolve valid_block_alloc fresh_block_alloc valid_new_block: mem.
+Hint Resolve valid_access_alloc_other valid_access_alloc_same: mem.
+Hint Resolve load_alloc_unchanged: mem.
+
+(** ** Properties related to [free]. *)
-Definition block_agree (b: block) (lo hi: Z) (m1 m2: mem) :=
- block_contents_agree lo hi
- (m1.(blocks) b) (m2.(blocks) b).
+Section FREE.
-Theorem block_agree_refl:
- forall (m: mem) (b: block) (lo hi: Z),
- block_agree b lo hi m m.
+Variable m: mem.
+Variable bf: block.
+
+Lemma valid_block_free_1:
+ forall b, valid_block m b -> valid_block (free m bf) b.
Proof.
- intros. hnf. auto.
+ unfold valid_block, free; intros; simpl; auto.
Qed.
-Theorem block_agree_sym:
- forall (m1 m2: mem) (b: block) (lo hi: Z),
- block_agree b lo hi m1 m2 ->
- block_agree b lo hi m2 m1.
+Lemma valid_block_free_2:
+ forall b, valid_block (free m bf) b -> valid_block m b.
Proof.
- intros. hnf. intros. symmetry. apply H. auto.
+ unfold valid_block, free; intros; simpl in *; auto.
Qed.
-Theorem block_agree_trans:
- forall (m1 m2 m3: mem) (b: block) (lo hi: Z),
- block_agree b lo hi m1 m2 ->
- block_agree b lo hi m2 m3 ->
- block_agree b lo hi m1 m3.
+Hint Resolve valid_block_free_1 valid_block_free_2: mem.
+
+Lemma low_bound_free:
+ forall b, b <> bf -> low_bound (free m bf) b = low_bound m b.
Proof.
- intros. hnf. intros.
- transitivity (contents (blocks m2 b) ofs).
- apply H; auto. apply H0; auto.
+ intros. unfold low_bound, free; simpl.
+ rewrite update_o; auto.
Qed.
-Lemma check_cont_agree:
- forall (c1 c2: contentmap) (lo hi: Z),
- contentmap_agree lo hi c1 c2 ->
- forall (n: nat) (ofs: Z),
- lo <= ofs -> ofs + Z_of_nat n <= hi ->
- check_cont n ofs c2 = check_cont n ofs c1.
+Lemma high_bound_free:
+ forall b, b <> bf -> high_bound (free m bf) b = high_bound m b.
Proof.
- induction n; intros; simpl.
- auto.
- rewrite inj_S in H1.
- rewrite H. case (c2 ofs); intros; auto.
- apply IHn; omega.
- omega.
+ intros. unfold high_bound, free; simpl.
+ rewrite update_o; auto.
Qed.
-Lemma getN_agree:
- forall (c1 c2: contentmap) (lo hi: Z),
- contentmap_agree lo hi c1 c2 ->
- forall (n: nat) (ofs: Z),
- lo <= ofs -> ofs + Z_of_nat n < hi ->
- getN n ofs c2 = getN n ofs c1.
+Lemma low_bound_free_same:
+ forall m b, low_bound (free m b) b = 0.
Proof.
- intros. unfold getN.
- rewrite (check_cont_agree c1 c2 lo hi H n (ofs + 1)).
- case (check_cont n (ofs + 1) c1).
- symmetry. apply H. omega. auto.
- omega. omega.
+ intros. unfold low_bound; simpl. rewrite update_s. simpl; omega.
Qed.
-Lemma load_contentmap_agree:
- forall (sz: memory_size) (c1 c2: contentmap) (lo hi ofs: Z),
- contentmap_agree lo hi c1 c2 ->
- lo <= ofs -> ofs + size_mem sz <= hi ->
- load_contents sz c2 ofs = load_contents sz c1 ofs.
+Lemma high_bound_free_same:
+ forall m b, high_bound (free m b) b = 0.
Proof.
- intros sz c1 c2 lo hi ofs EX LO.
- unfold load_contents, size_mem; case sz; intro HI;
- rewrite (getN_agree c1 c2 lo hi EX); auto; simpl Z_of_nat; omega.
+ intros. unfold high_bound; simpl. rewrite update_s. simpl; omega.
Qed.
-Lemma set_cont_agree:
- forall (lo hi: Z) (n: nat) (c1 c2: contentmap) (ofs: Z),
- contentmap_agree lo hi c1 c2 ->
- contentmap_agree lo hi (set_cont n ofs c1) (set_cont n ofs c2).
+Lemma valid_access_free_1:
+ forall chunk b ofs,
+ valid_access m chunk b ofs -> b <> bf ->
+ valid_access (free m bf) chunk b ofs.
Proof.
- induction n; simpl; intros.
- auto.
- red. intros p B.
- case (zeq p ofs); intro.
- subst p. repeat (rewrite update_s). reflexivity.
- repeat (rewrite update_o). apply IHn. assumption.
- assumption. auto. auto.
+ intros. inv H. constructor. auto with mem.
+ rewrite low_bound_free; auto. rewrite high_bound_free; auto.
Qed.
-Lemma setN_agree:
- forall (lo hi: Z) (n: nat) (c1 c2: contentmap) (ofs: Z) (v: content),
- contentmap_agree lo hi c1 c2 ->
- contentmap_agree lo hi (setN n ofs v c1) (setN n ofs v c2).
+Lemma valid_access_free_2:
+ forall chunk ofs, ~(valid_access (free m bf) chunk bf ofs).
Proof.
- intros. unfold setN. red; intros p B.
- case (zeq p ofs); intro.
- subst p. repeat (rewrite update_s). reflexivity.
- repeat (rewrite update_o; auto).
- exact (set_cont_agree lo hi n c1 c2 (ofs + 1) H p B).
+ intros; red; intros. inv H.
+ unfold free, low_bound in H1; simpl in H1. rewrite update_s in H1. simpl in H1.
+ unfold free, high_bound in H2; simpl in H2. rewrite update_s in H2. simpl in H2.
+ generalize (size_chunk_pos chunk). omega.
Qed.
-Lemma store_contentmap_agree:
- forall (sz: memory_size) (c1 c2: contentmap) (lo hi ofs: Z) (v: val),
- contentmap_agree lo hi c1 c2 ->
- contentmap_agree lo hi
- (store_contents sz c1 ofs v) (store_contents sz c2 ofs v).
+Hint Resolve valid_access_free_1 valid_access_free_2: mem.
+
+Lemma valid_access_free_inv:
+ forall chunk b ofs,
+ valid_access (free m bf) chunk b ofs ->
+ valid_access m chunk b ofs /\ b <> bf.
Proof.
- intros. unfold store_contents; case sz; apply setN_agree; auto.
+ intros. destruct (eq_block b bf). subst b.
+ elim (valid_access_free_2 _ _ H).
+ inv H. rewrite low_bound_free in H1; auto.
+ rewrite high_bound_free in H2; auto.
+ split; auto. constructor; auto with mem.
Qed.
-Lemma set_cont_outside_agree:
- forall (lo hi: Z) (n: nat) (c1 c2: contentmap) (ofs: Z),
- contentmap_agree lo hi c1 c2 ->
- ofs + Z_of_nat n <= lo \/ hi <= ofs ->
- contentmap_agree lo hi c1 (set_cont n ofs c2).
+Theorem load_free:
+ forall chunk b ofs,
+ b <> bf ->
+ load chunk (free m bf) b ofs = load chunk m b ofs.
Proof.
- induction n; intros; simpl.
- auto.
- red; intros p R. rewrite inj_S in H0.
- unfold update. case (zeq p ofs); intro.
- subst p. omegaContradiction.
- apply IHn. auto. omega. auto.
+ intros. unfold load.
+ destruct (in_bounds m chunk b ofs).
+ rewrite in_bounds_true; auto with mem.
+ unfold free; simpl. rewrite update_o; auto.
+ destruct (in_bounds (free m bf) chunk b ofs); auto.
+ elim n. elim (valid_access_free_inv _ _ _ v); auto.
+Qed.
+
+End FREE.
+
+(** ** Properties related to [free_list] *)
+
+Lemma valid_block_free_list_1:
+ forall bl m b, valid_block m b -> valid_block (free_list m bl) b.
+Proof.
+ induction bl; simpl; intros. auto.
+ apply valid_block_free_1; auto.
Qed.
-Lemma setN_outside_agree:
- forall (lo hi: Z) (n: nat) (c1 c2: contentmap) (ofs: Z) (v: content),
- contentmap_agree lo hi c1 c2 ->
- ofs + Z_of_nat n < lo \/ hi <= ofs ->
- contentmap_agree lo hi c1 (setN n ofs v c2).
+Lemma valid_block_free_list_2:
+ forall bl m b, valid_block (free_list m bl) b -> valid_block m b.
Proof.
- intros. unfold setN. red; intros p R.
- unfold update. case (zeq p ofs); intro.
- omegaContradiction.
- apply (set_cont_outside_agree lo hi n c1 c2 (ofs + 1) H).
- omega. auto.
+ induction bl; simpl; intros. auto.
+ apply IHbl. apply valid_block_free_2 with a; auto.
Qed.
-Lemma store_contentmap_outside_agree:
- forall (sz: memory_size) (c1 c2: contentmap) (lo hi ofs: Z) (v: val),
- contentmap_agree lo hi c1 c2 ->
- ofs + size_mem sz <= lo \/ hi <= ofs ->
- contentmap_agree lo hi c1 (store_contents sz c2 ofs v).
+Lemma valid_access_free_list:
+ forall chunk b ofs m bl,
+ valid_access m chunk b ofs -> ~In b bl ->
+ valid_access (free_list m bl) chunk b ofs.
Proof.
- intros until v.
- unfold store_contents; case sz; simpl; intros;
- apply setN_outside_agree; auto; simpl Z_of_nat; omega.
+ induction bl; simpl; intros. auto.
+ apply valid_access_free_1. apply IHbl. auto. intuition. intuition congruence.
Qed.
-Theorem load_agree:
- forall (chunk: memory_chunk) (m1 m2: mem)
- (b: block) (lo hi: Z) (ofs: Z) (v1 v2: val),
- block_agree b lo hi m1 m2 ->
- lo <= ofs -> ofs + size_chunk chunk <= hi ->
- load chunk m1 b ofs = Some v1 ->
- load chunk m2 b ofs = Some v2 ->
- v1 = v2.
+Lemma valid_access_free_list_inv:
+ forall chunk b ofs m bl,
+ valid_access (free_list m bl) chunk b ofs ->
+ ~In b bl /\ valid_access m chunk b ofs.
+Proof.
+ induction bl; simpl; intros.
+ tauto.
+ elim (valid_access_free_inv _ _ _ _ _ H); intros.
+ elim (IHbl H0); intros.
+ intuition congruence.
+Qed.
+
+(** ** Properties related to pointer validity *)
+
+Lemma valid_pointer_valid_access:
+ forall m b ofs,
+ valid_pointer m b ofs = true <-> valid_access m Mint8unsigned b ofs.
+Proof.
+ unfold valid_pointer; intros; split; intros.
+ destruct (andb_prop _ _ H). destruct (andb_prop _ _ H0).
+ constructor. red. eapply proj_sumbool_true; eauto.
+ eapply proj_sumbool_true; eauto.
+ change (size_chunk Mint8unsigned) with 1.
+ generalize (proj_sumbool_true _ H1). omega.
+ inv H. unfold proj_sumbool.
+ rewrite zlt_true; auto. rewrite zle_true; auto.
+ change (size_chunk Mint8unsigned) with 1 in H2.
+ rewrite zlt_true. auto. omega.
+Qed.
+
+Theorem valid_pointer_alloc:
+ forall (m1 m2: mem) (lo hi: Z) (b b': block) (ofs: Z),
+ alloc m1 lo hi = (m2, b') ->
+ valid_pointer m1 b ofs = true ->
+ valid_pointer m2 b ofs = true.
+Proof.
+ intros. rewrite valid_pointer_valid_access in H0.
+ rewrite valid_pointer_valid_access.
+ eauto with mem.
+Qed.
+
+Theorem valid_pointer_store:
+ forall (chunk: memory_chunk) (m1 m2: mem) (b b': block) (ofs ofs': Z) (v: val),
+ store chunk m1 b' ofs' v = Some m2 ->
+ valid_pointer m1 b ofs = true -> valid_pointer m2 b ofs = true.
+Proof.
+ intros. rewrite valid_pointer_valid_access in H0.
+ rewrite valid_pointer_valid_access.
+ eauto with mem.
+Qed.
+
+(** * Generic injections between memory states. *)
+
+Section GENERIC_INJECT.
+
+Definition meminj : Set := block -> option (block * Z).
+
+Variable val_inj: meminj -> val -> val -> Prop.
+
+(*
+Hypothesis val_inj_ptr:
+ forall mi b1 ofs1 b2 ofs2,
+ val_inj mi (Vptr b1 ofs1) (Vptr b2 ofs2) <->
+ exists delta, mi b1 = Some(b2, delta) /\ ofs2 = Int.repr (Int.signed ofs1 + delta).
+*)
+
+Hypothesis val_inj_undef:
+ forall mi, val_inj mi Vundef Vundef.
+
+Definition mem_inj (mi: meminj) (m1 m2: mem) :=
+ forall chunk b1 ofs v1 b2 delta,
+ mi b1 = Some(b2, delta) ->
+ load chunk m1 b1 ofs = Some v1 ->
+ exists v2, load chunk m2 b2 (ofs + delta) = Some v2 /\ val_inj mi v1 v2.
+
+Lemma valid_access_inj:
+ forall mi m1 m2 chunk b1 ofs b2 delta,
+ mi b1 = Some(b2, delta) ->
+ mem_inj mi m1 m2 ->
+ valid_access m1 chunk b1 ofs ->
+ valid_access m2 chunk b2 (ofs + delta).
Proof.
intros.
- generalize (load_inv _ _ _ _ _ H2). intros [K [L [M N]]].
- generalize (load_inv _ _ _ _ _ H3). intros [P [Q [R S]]].
- subst v1; subst v2. symmetry.
- decEq. eapply load_contentmap_agree.
- apply H. auto. auto.
-Qed.
-
-Theorem store_agree:
- forall (chunk: memory_chunk) (m1 m2 m1' m2': mem)
- (b: block) (lo hi: Z)
- (b': block) (ofs: Z) (v: val),
- block_agree b lo hi m1 m2 ->
- store chunk m1 b' ofs v = Some m1' ->
- store chunk m2 b' ofs v = Some m2' ->
- block_agree b lo hi m1' m2'.
+ assert (exists v1, load chunk m1 b1 ofs = Some v1) by eauto with mem.
+ destruct H2 as [v1 LOAD1].
+ destruct (H0 _ _ _ _ _ _ H LOAD1) as [v2 [LOAD2 VCP]].
+ eauto with mem.
+Qed.
+
+Hint Resolve valid_access_inj: mem.
+
+Lemma store_unmapped_inj:
+ forall mi m1 m2 b ofs v chunk m1',
+ mem_inj mi m1 m2 ->
+ mi b = None ->
+ store chunk m1 b ofs v = Some m1' ->
+ mem_inj mi m1' m2.
+Proof.
+ intros; red; intros.
+ assert (load chunk0 m1 b1 ofs0 = Some v1).
+ rewrite <- H3; symmetry. eapply load_store_other; eauto.
+ left. congruence.
+ eapply H; eauto.
+Qed.
+
+Lemma store_outside_inj:
+ forall mi m1 m2 chunk b ofs v m2',
+ mem_inj mi m1 m2 ->
+ (forall b' delta,
+ mi b' = Some(b, delta) ->
+ high_bound m1 b' + delta <= ofs
+ \/ ofs + size_chunk chunk <= low_bound m1 b' + delta) ->
+ store chunk m2 b ofs v = Some m2' ->
+ mem_inj mi m1 m2'.
+Proof.
+ intros; red; intros.
+ exploit H; eauto. intros [v2 [LOAD2 VINJ]].
+ exists v2; split; auto.
+ rewrite <- LOAD2. eapply load_store_other; eauto.
+ destruct (eq_block b2 b). subst b2.
+ right. generalize (H0 _ _ H2); intro.
+ assert (valid_access m1 chunk0 b1 ofs0) by eauto with mem.
+ inv H5. omega. auto.
+Qed.
+
+Definition meminj_no_overlap (mi: meminj) (m: mem) : Prop :=
+ forall b1 b1' delta1 b2 b2' delta2,
+ b1 <> b2 ->
+ mi b1 = Some (b1', delta1) ->
+ mi b2 = Some (b2', delta2) ->
+ b1' <> b2'
+ \/ low_bound m b1 >= high_bound m b1
+ \/ low_bound m b2 >= high_bound m b2
+ \/ high_bound m b1 + delta1 <= low_bound m b2 + delta2
+ \/ high_bound m b2 + delta2 <= low_bound m b1 + delta1.
+
+Lemma store_mapped_inj:
+ forall mi m1 m2 b1 ofs b2 delta v1 v2 chunk m1',
+ mem_inj mi m1 m2 ->
+ meminj_no_overlap mi m1 ->
+ mi b1 = Some(b2, delta) ->
+ store chunk m1 b1 ofs v1 = Some m1' ->
+ (forall chunk', size_chunk chunk' = size_chunk chunk ->
+ val_inj mi (Val.load_result chunk' v1) (Val.load_result chunk' v2)) ->
+ exists m2',
+ store chunk m2 b2 (ofs + delta) v2 = Some m2' /\ mem_inj mi m1' m2'.
Proof.
- intros.
- generalize (store_inv _ _ _ _ _ _ H0).
- intros [I [J [K [L [x M]]]]].
- generalize (store_inv _ _ _ _ _ _ H1).
- intros [P [Q [R [S [y T]]]]].
- red. red.
- rewrite M; rewrite T; unfold update.
- case (zeq b b'); intro; simpl.
- subst b'. apply store_contentmap_agree. assumption.
- apply H.
-Qed.
-
-Theorem store_outside_agree:
- forall (chunk: memory_chunk) (m1 m2 m2': mem)
- (b: block) (lo hi: Z)
- (b': block) (ofs: Z) (v: val),
- block_agree b lo hi m1 m2 ->
- b <> b' \/ ofs + size_chunk chunk <= lo \/ hi <= ofs ->
- store chunk m2 b' ofs v = Some m2' ->
- block_agree b lo hi m1 m2'.
+ intros.
+ assert (exists m2', store chunk m2 b2 (ofs + delta) v2 = Some m2') by eauto with mem.
+ destruct H4 as [m2' STORE2].
+ exists m2'; split. auto.
+ red. intros chunk' b1' ofs' v b2' delta' CP LOAD1.
+ assert (valid_access m1 chunk' b1' ofs') by eauto with mem.
+ generalize (load_store_characterization _ _ _ _ _ _ H2 _ _ _ H4).
+ destruct (load_store_classification chunk b1 ofs chunk' b1' ofs');
+ intro.
+ (* similar *)
+ subst b1' ofs'.
+ rewrite CP in H1. inv H1.
+ rewrite LOAD1 in H5. inv H5.
+ exists (Val.load_result chunk' v2). split.
+ eapply load_store_similar; eauto.
+ auto.
+ (* disjoint *)
+ rewrite LOAD1 in H5.
+ destruct (H _ _ _ _ _ _ CP (sym_equal H5)) as [v2' [LOAD2 VCP]].
+ exists v2'. split; auto.
+ rewrite <- LOAD2. eapply load_store_other; eauto.
+ destruct (eq_block b1 b1'). subst b1'.
+ rewrite CP in H1; inv H1.
+ right. elim o; [congruence | omega].
+ assert (valid_access m1 chunk b1 ofs) by eauto with mem.
+ generalize (H0 _ _ _ _ _ _ n H1 CP). intros [A | [A | [A | A]]].
+ auto.
+ inv H6. generalize (size_chunk_pos chunk). intro. omegaContradiction.
+ inv H4. generalize (size_chunk_pos chunk'). intro. omegaContradiction.
+ right. inv H4. inv H6. omega.
+ (* overlapping *)
+ subst b1'. rewrite CP in H1; inv H1.
+ assert (exists v2', load chunk' m2' b2 (ofs' + delta) = Some v2') by eauto with mem.
+ destruct H1 as [v2' LOAD2'].
+ assert (v2' = Vundef). eapply load_store_overlap; eauto.
+ omega. omega. omega.
+ exists v2'; split. auto.
+ replace v with Vundef by congruence. subst v2'. apply val_inj_undef.
+ (* mismatch *)
+ subst b1' ofs'. rewrite CP in H1; inv H1.
+ assert (exists v2', load chunk' m2' b2 (ofs + delta) = Some v2') by eauto with mem.
+ destruct H1 as [v2' LOAD2'].
+ assert (v2' = Vundef). eapply load_store_mismatch; eauto.
+ exists v2'; split. auto.
+ replace v with Vundef by congruence. subst v2'. apply val_inj_undef.
+Qed.
+
+Lemma alloc_parallel_inj:
+ forall mi m1 m2 lo1 hi1 m1' b1 lo2 hi2 m2' b2 delta,
+ mem_inj mi m1 m2 ->
+ alloc m1 lo1 hi1 = (m1', b1) ->
+ alloc m2 lo2 hi2 = (m2', b2) ->
+ mi b1 = Some(b2, delta) ->
+ lo2 <= lo1 + delta -> hi1 + delta <= hi2 ->
+ mem_inj mi m1' m2'.
+Proof.
+ intros; red; intros.
+ exploit (valid_access_alloc_inv m1); eauto with mem.
+ intros [A | [A [B C]]].
+ assert (load chunk m1 b0 ofs = Some v1).
+ rewrite <- H6. symmetry. eapply load_alloc_unchanged; eauto with mem.
+ exploit H; eauto. intros [v2 [LOAD2 VINJ]].
+ exists v2; split.
+ rewrite <- LOAD2. eapply load_alloc_unchanged; eauto with mem.
+ auto.
+ subst b0. rewrite H2 in H5. inversion H5. subst b3 delta0.
+ assert (v1 = Vundef). eapply load_alloc_same with (m1 := m1); eauto.
+ subst v1.
+ assert (exists v2, load chunk m2' b2 (ofs + delta) = Some v2).
+ apply valid_access_load.
+ eapply valid_access_alloc_same; eauto. omega. omega.
+ destruct H7 as [v2 LOAD2].
+ assert (v2 = Vundef). eapply load_alloc_same with (m1 := m2); eauto.
+ subst v2.
+ exists Vundef; split. auto. apply val_inj_undef.
+Qed.
+
+Lemma alloc_right_inj:
+ forall mi m1 m2 lo hi b2 m2',
+ mem_inj mi m1 m2 ->
+ alloc m2 lo hi = (m2', b2) ->
+ mem_inj mi m1 m2'.
Proof.
- intros.
- generalize (store_inv _ _ _ _ _ _ H1).
- intros [I [J [K [L [x M]]]]].
- red. red. rewrite M; unfold update;
- case (zeq b b'); intro; simpl.
- subst b'. apply store_contentmap_outside_agree.
- assumption.
- elim H0; intro. tauto. exact H2.
- apply H.
+ intros; red; intros.
+ exploit H; eauto. intros [v2 [LOAD2 VINJ]].
+ exists v2; split; auto.
+ assert (valid_block m2 b0).
+ apply valid_access_valid_block with chunk (ofs + delta).
+ eauto with mem.
+ rewrite <- LOAD2. eapply load_alloc_unchanged; eauto.
+Qed.
+
+Hypothesis val_inj_undef_any:
+ forall mi v, val_inj mi Vundef v.
+
+Lemma alloc_left_unmapped_inj:
+ forall mi m1 m2 lo hi b1 m1',
+ mem_inj mi m1 m2 ->
+ alloc m1 lo hi = (m1', b1) ->
+ mi b1 = None ->
+ mem_inj mi m1' m2.
+Proof.
+ intros; red; intros.
+ exploit (valid_access_alloc_inv m1); eauto with mem.
+ intros [A | [A [B C]]].
+ eapply H; eauto.
+ rewrite <- H3. symmetry. eapply load_alloc_unchanged; eauto with mem.
+ subst b0. congruence.
+Qed.
+
+Lemma alloc_left_mapped_inj:
+ forall mi m1 m2 lo hi b1 m1' b2 delta,
+ mem_inj mi m1 m2 ->
+ alloc m1 lo hi = (m1', b1) ->
+ mi b1 = Some(b2, delta) ->
+ valid_block m2 b2 ->
+ low_bound m2 b2 <= lo + delta -> hi + delta <= high_bound m2 b2 ->
+ mem_inj mi m1' m2.
+Proof.
+ intros; red; intros.
+ exploit (valid_access_alloc_inv m1); eauto with mem.
+ intros [A | [A [B C]]].
+ eapply H; eauto.
+ rewrite <- H6. symmetry. eapply load_alloc_unchanged; eauto with mem.
+ subst b0. rewrite H1 in H5. inversion H5. subst b3 delta0.
+ assert (v1 = Vundef). eapply load_alloc_same with (m1 := m1); eauto.
+ subst v1.
+ assert (exists v2, load chunk m2 b2 (ofs + delta) = Some v2).
+ apply valid_access_load. constructor. auto. omega. omega.
+ destruct H7 as [v2 LOAD2]. exists v2; split. auto.
+ apply val_inj_undef_any.
+Qed.
+
+Lemma free_parallel_inj:
+ forall mi m1 m2 b1 b2 delta,
+ mem_inj mi m1 m2 ->
+ mi b1 = Some(b2, delta) ->
+ (forall b delta', mi b = Some(b2, delta') -> b = b1) ->
+ mem_inj mi (free m1 b1) (free m2 b2).
+Proof.
+ intros; red; intros.
+ exploit valid_access_free_inv; eauto with mem. intros [A B].
+ assert (load chunk m1 b0 ofs = Some v1).
+ rewrite <- H3. symmetry. apply load_free. auto.
+ exploit H; eauto. intros [v2 [LOAD2 INJ]].
+ exists v2; split.
+ rewrite <- LOAD2. apply load_free.
+ red; intro; subst b3. elim B. eauto.
+ auto.
Qed.
-(** * Store extensions *)
+Lemma free_left_inj:
+ forall mi m1 m2 b1,
+ mem_inj mi m1 m2 ->
+ mem_inj mi (free m1 b1) m2.
+Proof.
+ intros; red; intros.
+ exploit valid_access_free_inv; eauto with mem. intros [A B].
+ eapply H; eauto with mem.
+ rewrite <- H1; symmetry; eapply load_free; eauto.
+Qed.
+
+Lemma free_list_left_inj:
+ forall mi bl m1 m2,
+ mem_inj mi m1 m2 ->
+ mem_inj mi (free_list m1 bl) m2.
+Proof.
+ induction bl; intros; simpl.
+ auto.
+ apply free_left_inj. auto.
+Qed.
+
+Lemma free_right_inj:
+ forall mi m1 m2 b2,
+ mem_inj mi m1 m2 ->
+ (forall b1 delta chunk ofs,
+ mi b1 = Some(b2, delta) -> ~(valid_access m1 chunk b1 ofs)) ->
+ mem_inj mi m1 (free m2 b2).
+Proof.
+ intros; red; intros.
+ assert (b0 <> b2).
+ red; intro; subst b0. elim (H0 b1 delta chunk ofs H1).
+ eauto with mem.
+ exploit H; eauto. intros [v2 [LOAD2 INJ]].
+ exists v2; split; auto.
+ rewrite <- LOAD2. apply load_free. auto.
+Qed.
+
+Lemma valid_pointer_inj:
+ forall mi m1 m2 b1 ofs b2 delta,
+ mi b1 = Some(b2, delta) ->
+ mem_inj mi m1 m2 ->
+ valid_pointer m1 b1 ofs = true ->
+ valid_pointer m2 b2 (ofs + delta) = true.
+Proof.
+ intros. rewrite valid_pointer_valid_access in H1.
+ rewrite valid_pointer_valid_access. eauto with mem.
+Qed.
+
+End GENERIC_INJECT.
+
+(** ** Store extensions *)
(** A store [m2] extends a store [m1] if [m2] can be obtained from [m1]
by increasing the sizes of the memory blocks of [m1] (decreasing
the low bounds, increasing the high bounds), while still keeping the
- same contents for block offsets that are valid in [m1].
- This notion is used in the proof of semantic equivalence in
- module [Machenv]. *)
+ same contents for block offsets that are valid in [m1]. *)
-Definition block_contents_extends (c1 c2: block_contents) :=
- c2.(low) <= c1.(low) /\ c1.(high) <= c2.(high) /\
- contentmap_agree c1.(low) c1.(high) c1.(contents) c2.(contents).
+Definition inject_id : meminj := fun b => Some(b, 0).
+
+Definition val_inj_id (mi: meminj) (v1 v2: val) : Prop := v1 = v2.
Definition extends (m1 m2: mem) :=
- m1.(nextblock) = m2.(nextblock) /\
- forall (b: block),
- b < m1.(nextblock) ->
- block_contents_extends (m1.(blocks) b) (m2.(blocks) b).
+ nextblock m1 = nextblock m2 /\ mem_inj val_inj_id inject_id m1 m2.
Theorem extends_refl:
forall (m: mem), extends m m.
Proof.
- intro. red. split.
- reflexivity.
- intros. red.
- split. omega. split. omega.
- red. intros. reflexivity.
+ intros; split. auto.
+ red; unfold inject_id; intros. inv H.
+ exists v1; split. replace (ofs + 0) with ofs by omega. auto.
+ unfold val_inj_id; auto.
Qed.
Theorem alloc_extends:
@@ -1293,16 +1519,18 @@ Theorem alloc_extends:
alloc m2 lo2 hi2 = (m2', b2) ->
b1 = b2 /\ extends m1' m2'.
Proof.
- unfold extends, alloc; intros.
- injection H2; intros; subst m1'; subst b1.
- injection H3; intros; subst m2'; subst b2.
- simpl. intuition.
- rewrite <- H4. case (zeq b (nextblock m1)); intro.
- subst b. repeat rewrite update_s.
- red; simpl. intuition.
- red; intros; reflexivity.
- repeat rewrite update_o. apply H5. omega.
- auto. auto.
+ intros. destruct H.
+ assert (b1 = b2).
+ transitivity (nextblock m1). eapply alloc_result; eauto.
+ symmetry. rewrite H. eapply alloc_result; eauto.
+ subst b2. split. auto. split.
+ rewrite (nextblock_alloc _ _ _ _ _ H2).
+ rewrite (nextblock_alloc _ _ _ _ _ H3).
+ congruence.
+ eapply alloc_parallel_inj; eauto.
+ unfold val_inj_id; auto.
+ unfold inject_id; eauto.
+ omega. omega.
Qed.
Theorem free_extends:
@@ -1310,16 +1538,11 @@ Theorem free_extends:
extends m1 m2 ->
extends (free m1 b) (free m2 b).
Proof.
- unfold extends, free; intros.
- simpl. intuition.
- red; intros; simpl.
- case (zeq b0 b); intro.
- subst b0; repeat (rewrite update_s).
- simpl. split. omega. split. omega.
- red. intros. omegaContradiction.
- repeat (rewrite update_o).
- exact (H1 b0 H).
- auto. auto.
+ intros. destruct H. split.
+ simpl; auto.
+ eapply free_parallel_inj; eauto.
+ unfold inject_id. eauto.
+ unfold inject_id; intros. congruence.
Qed.
Theorem load_extends:
@@ -1328,18 +1551,10 @@ Theorem load_extends:
load chunk m1 b ofs = Some v ->
load chunk m2 b ofs = Some v.
Proof.
- intros sz m1 m2 b ofs v (X, Y) L.
- generalize (load_inv _ _ _ _ _ L).
- intros (A, (B, (C, D))).
- unfold load. rewrite <- X. rewrite zlt_true; auto.
- generalize (Y b A); intros [M [P Q]].
- rewrite in_bounds_holds.
- rewrite <- D.
- decEq. decEq.
- apply load_contentmap_agree with
- (lo := low((blocks m1) b))
- (hi := high((blocks m1) b)); auto.
- omega. omega.
+ intros. destruct H.
+ exploit H1; eauto. unfold inject_id. eauto.
+ unfold val_inj_id. intros [v2 [LOAD EQ]].
+ replace (ofs + 0) with ofs in LOAD by omega. congruence.
Qed.
Theorem store_within_extends:
@@ -1348,24 +1563,21 @@ Theorem store_within_extends:
store chunk m1 b ofs v = Some m1' ->
exists m2', store chunk m2 b ofs v = Some m2' /\ extends m1' m2'.
Proof.
- intros sz m1 m2 m1' b ofs v (X, Y) STORE.
- generalize (store_inv _ _ _ _ _ _ STORE).
- intros (A, (B, (C, (D, (x, E))))).
- generalize (Y b A); intros [M [P Q]].
- unfold store. rewrite <- X. rewrite zlt_true; auto.
- case (in_bounds sz ofs (blocks m2 b)); intro.
- exists (unchecked_store sz m2 b ofs v a).
- split. auto.
+ intros. destruct H.
+ exploit store_mapped_inj; eauto.
+ unfold val_inj_id; eauto.
+ unfold meminj_no_overlap, inject_id; intros.
+ inv H3. inv H4. auto.
+ unfold inject_id; eauto.
+ unfold val_inj_id; intros. eauto.
+ intros [m2' [STORE MINJ]].
+ exists m2'; split.
+ replace (ofs + 0) with ofs in STORE by omega. auto.
split.
- unfold unchecked_store; simpl. congruence.
- intros b' LT.
- unfold block_contents_extends, unchecked_store, block_contents_agree.
- rewrite E; unfold update; simpl.
- case (zeq b' b); intro; simpl.
- subst b'. split. omega. split. omega.
- apply store_contentmap_agree. auto.
- apply Y. rewrite <- D. auto.
- omegaContradiction.
+ rewrite (nextblock_store _ _ _ _ _ _ H0).
+ rewrite (nextblock_store _ _ _ _ _ _ STORE).
+ auto.
+ auto.
Qed.
Theorem store_outside_extends:
@@ -1375,59 +1587,147 @@ Theorem store_outside_extends:
store chunk m2 b ofs v = Some m2' ->
extends m1 m2'.
Proof.
- intros sz m1 m2 m2' b ofs v (X, Y) BOUNDS STORE.
- generalize (store_inv _ _ _ _ _ _ STORE).
- intros (A, (B, (C, (D, (x, E))))).
- split.
- congruence.
- intros b' LT.
- rewrite E; unfold update; case (zeq b' b); intro.
- subst b'. generalize (Y b LT). intros [M [P Q]].
- red; simpl. split. omega. split. omega.
- apply store_contentmap_outside_agree.
- assumption. exact BOUNDS.
- auto.
-Qed.
-
-(** * Memory extensionality properties *)
-
-Lemma block_contents_exten:
- forall (c1 c2: block_contents),
- c1.(low) = c2.(low) ->
- c1.(high) = c2.(high) ->
- block_contents_agree c1.(low) c1.(high) c1 c2 ->
- c1 = c2.
-Proof.
- intros. caseEq c1; intros lo1 hi1 m1 UO1 EQ1. subst c1.
- caseEq c2; intros lo2 hi2 m2 UO2 EQ2. subst c2.
- simpl in *. subst lo2 hi2.
- assert (m1 = m2).
- unfold contentmap. apply extensionality. intro.
- case (zlt x lo1); intro.
- rewrite UO1. rewrite UO2. auto. tauto. tauto.
- case (zlt x hi1); intro.
- apply H1. omega.
- rewrite UO1. rewrite UO2. auto. tauto. tauto.
- subst m2.
- assert (UO1 = UO2).
- apply proof_irrelevance.
- subst UO2. reflexivity.
-Qed.
-
-Theorem mem_exten:
- forall m1 m2,
- m1.(nextblock) = m2.(nextblock) ->
- (forall b, m1.(blocks) b = m2.(blocks) b) ->
- m1 = m2.
-Proof.
- intros. destruct m1 as [map1 nb1 nextpos1]. destruct m2 as [map2 nb2 nextpos2].
- simpl in *. subst nb2.
- assert (map1 = map2). apply extensionality. assumption.
- assert (nextpos1 = nextpos2). apply proof_irrelevance.
+ intros. destruct H. split.
+ rewrite (nextblock_store _ _ _ _ _ _ H1). auto.
+ eapply store_outside_inj; eauto.
+ unfold inject_id; intros. inv H3. omega.
+Qed.
+
+Theorem valid_pointer_extends:
+ forall m1 m2 b ofs,
+ extends m1 m2 -> valid_pointer m1 b ofs = true ->
+ valid_pointer m2 b ofs = true.
+Proof.
+ intros. destruct H.
+ replace ofs with (ofs + 0) by omega.
+ apply valid_pointer_inj with val_inj_id inject_id m1 b; auto.
+Qed.
+
+(** * The ``less defined than'' relation over memory states *)
+
+(** A memory state [m1] is less defined than [m2] if, for all addresses,
+ the value [v1] read in [m1] at this address is less defined than
+ the value [v2] read in [m2], that is, either [v1 = v2] or [v1 = Vundef]. *)
+
+Definition val_inj_lessdef (mi: meminj) (v1 v2: val) : Prop :=
+ Val.lessdef v1 v2.
+
+Definition lessdef (m1 m2: mem) : Prop :=
+ nextblock m1 = nextblock m2 /\
+ mem_inj val_inj_lessdef inject_id m1 m2.
+
+Lemma lessdef_refl:
+ forall m, lessdef m m.
+Proof.
+ intros; split. auto.
+ red; intros. unfold inject_id in H. inv H.
+ exists v1; split. replace (ofs + 0) with ofs by omega. auto.
+ red. constructor.
+Qed.
+
+Lemma load_lessdef:
+ forall m1 m2 chunk b ofs v1,
+ lessdef m1 m2 -> load chunk m1 b ofs = Some v1 ->
+ exists v2, load chunk m2 b ofs = Some v2 /\ Val.lessdef v1 v2.
+Proof.
+ intros. destruct H.
+ exploit H1; eauto. unfold inject_id. eauto.
+ intros [v2 [LOAD INJ]]. exists v2; split.
+ replace ofs with (ofs + 0) by omega. auto.
+ auto.
+Qed.
+
+Lemma loadv_lessdef:
+ forall m1 m2 chunk addr1 addr2 v1,
+ lessdef m1 m2 -> Val.lessdef addr1 addr2 ->
+ loadv chunk m1 addr1 = Some v1 ->
+ exists v2, loadv chunk m2 addr2 = Some v2 /\ Val.lessdef v1 v2.
+Proof.
+ intros. inv H0.
+ destruct addr2; simpl in *; try discriminate.
+ eapply load_lessdef; eauto.
+ simpl in H1; discriminate.
+Qed.
+
+Lemma store_lessdef:
+ forall m1 m2 chunk b ofs v1 v2 m1',
+ lessdef m1 m2 -> Val.lessdef v1 v2 ->
+ store chunk m1 b ofs v1 = Some m1' ->
+ exists m2', store chunk m2 b ofs v2 = Some m2' /\ lessdef m1' m2'.
+Proof.
+ intros. destruct H.
+ exploit store_mapped_inj; eauto.
+ unfold val_inj_lessdef; intros; constructor.
+ red; unfold inject_id; intros. inv H4. inv H5. auto.
+ unfold inject_id; eauto.
+ unfold val_inj_lessdef; intros.
+ apply Val.load_result_lessdef. eexact H0.
+ intros [m2' [STORE MINJ]].
+ exists m2'; split. replace ofs with (ofs + 0) by omega. auto.
+ split.
+ rewrite (nextblock_store _ _ _ _ _ _ H1).
+ rewrite (nextblock_store _ _ _ _ _ _ STORE).
+ auto.
+ auto.
+Qed.
+
+Lemma storev_lessdef:
+ forall m1 m2 chunk addr1 v1 addr2 v2 m1',
+ lessdef m1 m2 -> Val.lessdef addr1 addr2 -> Val.lessdef v1 v2 ->
+ storev chunk m1 addr1 v1 = Some m1' ->
+ exists m2', storev chunk m2 addr2 v2 = Some m2' /\ lessdef m1' m2'.
+Proof.
+ intros. inv H0.
+ destruct addr2; simpl in H2; try discriminate.
+ simpl. eapply store_lessdef; eauto.
+ discriminate.
+Qed.
+
+Lemma alloc_lessdef:
+ forall m1 m2 lo hi b1 m1' b2 m2',
+ lessdef m1 m2 -> alloc m1 lo hi = (m1', b1) -> alloc m2 lo hi = (m2', b2) ->
+ b1 = b2 /\ lessdef m1' m2'.
+Proof.
+ intros. destruct H.
+ assert (b1 = b2).
+ transitivity (nextblock m1). eapply alloc_result; eauto.
+ symmetry. rewrite H. eapply alloc_result; eauto.
+ subst b2. split. auto. split.
+ rewrite (nextblock_alloc _ _ _ _ _ H0).
+ rewrite (nextblock_alloc _ _ _ _ _ H1).
congruence.
+ eapply alloc_parallel_inj; eauto.
+ unfold val_inj_lessdef; auto.
+ unfold inject_id; eauto.
+ omega. omega.
Qed.
-(** * Store injections *)
+Lemma free_lessdef:
+ forall m1 m2 b, lessdef m1 m2 -> lessdef (free m1 b) (free m2 b).
+Proof.
+ intros. destruct H. split.
+ simpl; auto.
+ eapply free_parallel_inj; eauto.
+ unfold inject_id. eauto.
+ unfold inject_id; intros. congruence.
+Qed.
+
+Lemma valid_block_lessdef:
+ forall m1 m2 b, lessdef m1 m2 -> valid_block m1 b -> valid_block m2 b.
+Proof.
+ unfold valid_block. intros. destruct H. rewrite <- H; auto.
+Qed.
+
+Lemma valid_pointer_lessdef:
+ forall m1 m2 b ofs,
+ lessdef m1 m2 -> valid_pointer m1 b ofs = true -> valid_pointer m2 b ofs = true.
+Proof.
+ intros. destruct H.
+ replace ofs with (ofs + 0) by omega.
+ apply valid_pointer_inj with val_inj_lessdef inject_id m1 b; auto.
+Qed.
+
+(** ** Memory injections *)
(** A memory injection [f] is a function from addresses to either [None]
or [Some] of an address and an offset. It defines a correspondence
@@ -1437,718 +1737,358 @@ Qed.
a sub-block at offset [ofs] of the block [b'] in [m2].
*)
-Definition meminj := (block -> option (block * Z))%type.
-
-Section MEM_INJECT.
-
-Variable f: meminj.
-
(** A memory injection defines a relation between values that is the
identity relation, except for pointer values which are shifted
as prescribed by the memory injection. *)
-Inductive val_inject: val -> val -> Prop :=
+Inductive val_inject (mi: meminj): val -> val -> Prop :=
| val_inject_int:
- forall i, val_inject (Vint i) (Vint i)
+ forall i, val_inject mi (Vint i) (Vint i)
| val_inject_float:
- forall f, val_inject (Vfloat f) (Vfloat f)
+ forall f, val_inject mi (Vfloat f) (Vfloat f)
| val_inject_ptr:
forall b1 ofs1 b2 ofs2 x,
- f b1 = Some (b2, x) ->
+ mi b1 = Some (b2, x) ->
ofs2 = Int.add ofs1 (Int.repr x) ->
- val_inject (Vptr b1 ofs1) (Vptr b2 ofs2)
+ val_inject mi (Vptr b1 ofs1) (Vptr b2 ofs2)
| val_inject_undef: forall v,
- val_inject Vundef v.
+ val_inject mi Vundef v.
Hint Resolve val_inject_int val_inject_float val_inject_ptr
-val_inject_undef.
+ val_inject_undef.
-Inductive val_list_inject: list val -> list val-> Prop:=
+Inductive val_list_inject (mi: meminj): list val -> list val-> Prop:=
| val_nil_inject :
- val_list_inject nil nil
+ val_list_inject mi nil nil
| val_cons_inject : forall v v' vl vl' ,
- val_inject v v' -> val_list_inject vl vl'->
- val_list_inject (v::vl) (v':: vl').
-
-Inductive val_content_inject: memory_size -> val -> val -> Prop :=
- | val_content_inject_base:
- forall sz v1 v2,
- val_inject v1 v2 ->
- val_content_inject sz v1 v2
- | val_content_inject_8:
- forall n1 n2,
- Int.cast8unsigned n1 = Int.cast8unsigned n2 ->
- val_content_inject Size8 (Vint n1) (Vint n2)
- | val_content_inject_16:
- forall n1 n2,
- Int.cast16unsigned n1 = Int.cast16unsigned n2 ->
- val_content_inject Size16 (Vint n1) (Vint n2)
- | val_content_inject_32:
- forall f1 f2,
- Float.singleoffloat f1 = Float.singleoffloat f2 ->
- val_content_inject Size32 (Vfloat f1) (Vfloat f2).
+ val_inject mi v v' -> val_list_inject mi vl vl'->
+ val_list_inject mi (v :: vl) (v' :: vl').
-Hint Resolve val_content_inject_base.
-
-Inductive content_inject: content -> content -> Prop :=
- | content_inject_undef:
- forall c,
- content_inject Undef c
- | content_inject_datum8:
- forall v1 v2,
- val_content_inject Size8 v1 v2 ->
- content_inject (Datum8 v1) (Datum8 v2)
- | content_inject_datum16:
- forall v1 v2,
- val_content_inject Size16 v1 v2 ->
- content_inject (Datum16 v1) (Datum16 v2)
- | content_inject_datum32:
- forall v1 v2,
- val_content_inject Size32 v1 v2 ->
- content_inject (Datum32 v1) (Datum32 v2)
- | content_inject_datum64:
- forall v1 v2,
- val_content_inject Size64 v1 v2 ->
- content_inject (Datum64 v1) (Datum64 v2)
- | content_inject_cont:
- content_inject Cont Cont.
-
-Hint Resolve content_inject_undef content_inject_datum8
-content_inject_datum16 content_inject_datum32 content_inject_datum64
-content_inject_cont.
-
-Definition contentmap_inject (c1 c2: contentmap) (lo hi delta: Z) : Prop :=
- forall x, lo <= x < hi ->
- content_inject (c1 x) (c2 (x + delta)).
-
-(** A block contents [c1] injects into another block content [c2] at
- offset [delta] if the contents of [c1] at all valid offsets
- correspond to the contents of [c2] at the same offsets shifted by [delta].
- Some additional conditions are imposed to guard against arithmetic
- overflow in address computations. *)
-
-Record block_contents_inject (c1 c2: block_contents) (delta: Z) : Prop :=
- mk_block_contents_inject {
- bci_range1: Int.min_signed <= delta <= Int.max_signed;
- bci_range2: delta = 0 \/
- (Int.min_signed <= c2.(low) /\ c2.(high) <= Int.max_signed);
- bci_lowhigh:forall x, c1.(low) <= x < c1.(high) ->
- c2.(low) <= x+delta < c2.(high) ;
- bci_contents:
- contentmap_inject c1.(contents) c2.(contents) c1.(low) c1.(high) delta
- }.
+Hint Resolve val_nil_inject val_cons_inject.
(** A memory state [m1] injects into another memory state [m2] via the
memory injection [f] if the following conditions hold:
+- loads in [m1] must have matching loads in [m2] in the sense
+ of the [mem_inj] predicate;
- unallocated blocks in [m1] must be mapped to [None] by [f];
-- if [f b = Some(b', delta)], [b'] must be valid in [m2] and
- the contents of [b] in [m1] must inject into the contents of [b'] in [m2]
- with offset [delta];
-- distinct blocks in [m1] cannot be mapped to overlapping sub-blocks in [m2].
+- if [f b = Some(b', delta)], [b'] must be valid in [m2];
+- distinct blocks in [m1] are mapped to non-overlapping sub-blocks in [m2];
+- the sizes of [m2]'s blocks are representable with signed machine integers;
+- the offsets [delta] are representable with signed machine integers.
*)
-Record mem_inject (m1 m2: mem) : Prop :=
+Record mem_inject (f: meminj) (m1 m2: mem) : Prop :=
mk_mem_inject {
+ mi_inj:
+ mem_inj val_inject f m1 m2;
mi_freeblocks:
- forall b, b >= m1.(nextblock) -> f b = None;
+ forall b, ~(valid_block m1 b) -> f b = None;
mi_mappedblocks:
+ forall b b' delta, f b = Some(b', delta) -> valid_block m2 b';
+ mi_no_overlap:
+ meminj_no_overlap f m1;
+ mi_range_1:
forall b b' delta,
f b = Some(b', delta) ->
- b' < m2.(nextblock) /\
- block_contents_inject (m1.(blocks) b)
- (m2.(blocks) b')
- delta;
- mi_no_overlap:
- forall b1 b2 b1' b2' delta1 delta2,
- b1 <> b2 ->
- f b1 = Some (b1', delta1) ->
- f b2 = Some (b2', delta2) ->
- b1' <> b2'
- \/ (forall x1 x2, low_bound m1 b1 <= x1 < high_bound m1 b1 ->
- low_bound m1 b2 <= x2 < high_bound m1 b2 ->
- x1+delta1 <> x2+delta2)
- }.
+ Int.min_signed <= delta <= Int.max_signed;
+ mi_range_2:
+ forall b b' delta,
+ f b = Some(b', delta) ->
+ delta = 0 \/ (Int.min_signed <= low_bound m2 b' /\ high_bound m2 b' <= Int.max_signed)
+ }.
+
(** The following lemmas establish the absence of machine integer overflow
during address computations. *)
-Lemma size_mem_pos: forall sz, size_mem sz > 0.
-Proof. destruct sz; simpl; omega. Qed.
-
-Lemma size_chunk_pos: forall chunk, size_chunk chunk > 0.
-Proof. intros. unfold size_chunk. apply size_mem_pos. Qed.
-
Lemma address_inject:
- forall m1 m2 chunk b1 ofs1 b2 ofs2 x,
- mem_inject m1 m2 ->
- (m1.(blocks) b1).(low) <= Int.signed ofs1 ->
- Int.signed ofs1 + size_chunk chunk <= (m1.(blocks) b1).(high) ->
- f b1 = Some (b2, x) ->
- ofs2 = Int.add ofs1 (Int.repr x) ->
- Int.signed ofs2 = Int.signed ofs1 + x.
+ forall f m1 m2 chunk b1 ofs1 b2 delta,
+ mem_inject f m1 m2 ->
+ valid_access m1 chunk b1 (Int.signed ofs1) ->
+ f b1 = Some (b2, delta) ->
+ Int.signed (Int.add ofs1 (Int.repr delta)) = Int.signed ofs1 + delta.
Proof.
- intros.
- generalize (size_chunk_pos chunk). intro.
- generalize (mi_mappedblocks m1 m2 H _ _ _ H2). intros [C D].
- inversion D.
- elim bci_range4 ; intro.
- (**x=0**)
- subst x . rewrite Zplus_0_r. rewrite Int.add_zero in H3.
- subst ofs2 ; auto .
- (**x<>0**)
- rewrite H3. rewrite Int.add_signed. repeat rewrite Int.signed_repr.
- auto. auto.
- assert (low (blocks m1 b1) <= Int.signed ofs1 < high (blocks m1 b1)).
- omega.
- generalize (bci_lowhigh0 (Int.signed ofs1) H6). omega.
- auto.
+ intros. inversion H.
+ elim (mi_range_4 _ _ _ H1); intro.
+ (* delta = 0 *)
+ subst delta. change (Int.repr 0) with Int.zero.
+ rewrite Int.add_zero. omega.
+ (* delta <> 0 *)
+ rewrite Int.add_signed.
+ repeat rewrite Int.signed_repr. auto.
+ eauto.
+ assert (valid_access m2 chunk b2 (Int.signed ofs1 + delta)).
+ eapply valid_access_inj; eauto.
+ inv H3. generalize (size_chunk_pos chunk); omega.
+ eauto.
Qed.
Lemma valid_pointer_inject_no_overflow:
- forall m1 m2 b ofs b' x,
- mem_inject m1 m2 ->
+ forall f m1 m2 b ofs b' x,
+ mem_inject f m1 m2 ->
valid_pointer m1 b (Int.signed ofs) = true ->
f b = Some(b', x) ->
Int.min_signed <= Int.signed ofs + Int.signed (Int.repr x) <= Int.max_signed.
Proof.
- intros. unfold valid_pointer in H0.
- destruct (zlt b (nextblock m1)); try discriminate.
- destruct (zle (low (blocks m1 b)) (Int.signed ofs)); try discriminate.
- destruct (zlt (Int.signed ofs) (high (blocks m1 b))); try discriminate.
- inversion H. generalize (mi_mappedblocks0 _ _ _ H1).
- intros [A B]. inversion B.
- elim bci_range4 ; intro.
- (**x=0**)
- rewrite Int.signed_repr ; auto.
- subst x . rewrite Zplus_0_r. apply Int.signed_range .
- (**x<>0**)
- generalize (bci_lowhigh0 _ (conj z0 z1)). intro.
- rewrite Int.signed_repr. omega. auto.
-Qed.
-
-(** Relation between injections and loads. *)
-
-Lemma check_cont_inject:
- forall c1 c2 lo hi delta,
- contentmap_inject c1 c2 lo hi delta ->
- forall n p,
- lo <= p -> p + Z_of_nat n <= hi ->
- check_cont n p c1 = true ->
- check_cont n (p + delta) c2 = true.
-Proof.
- induction n.
- intros. simpl. reflexivity.
- simpl check_cont. rewrite inj_S. intros p H0 H1.
- assert (lo <= p < hi). omega.
- generalize (H p H2). intro. inversion H3; intros; try discriminate.
- replace (p + delta + 1) with ((p + 1) + delta).
- apply IHn. omega. omega. auto.
+ intros. inv H. rewrite valid_pointer_valid_access in H0.
+ assert (valid_access m2 Mint8unsigned b' (Int.signed ofs + x)).
+ eapply valid_access_inj; eauto.
+ inv H. change (size_chunk Mint8unsigned) with 1 in H4.
+ rewrite Int.signed_repr; eauto.
+ exploit mi_range_4; eauto. intros [A | [A B]].
+ subst x. rewrite Zplus_0_r. apply Int.signed_range.
omega.
Qed.
-Hint Resolve check_cont_inject.
-
-Lemma getN_inject:
- forall c1 c2 lo hi delta,
- contentmap_inject c1 c2 lo hi delta ->
- forall n p,
- lo <= p -> p + Z_of_nat n < hi ->
- content_inject (getN n p c1) (getN n (p + delta) c2).
-Proof.
- intros. simpl in H1.
- assert (lo <= p < hi). omega.
- unfold getN.
- caseEq (check_cont n (p + 1) c1); intro.
- replace (check_cont n (p + delta + 1) c2) with true.
- apply H. assumption.
- symmetry. replace (p + delta + 1) with ((p + 1) + delta).
- eapply check_cont_inject; eauto.
- omega. omega. omega.
- constructor.
-Qed.
-
-Hint Resolve getN_inject.
-
-Definition ztonat (z:Z): nat:=
-match z with
-| Z0 => O
-| Zpos p => (nat_of_P p)
-| Zneg p =>O
-end.
-
-Lemma load_contents_inject:
- forall sz c1 c2 lo hi delta p,
- contentmap_inject c1 c2 lo hi delta ->
- lo <= p -> p + size_mem sz <= hi ->
- val_content_inject sz (load_contents sz c1 p) (load_contents sz c2 (p + delta)).
-Proof.
-intros.
-assert (content_inject (getN (ztonat (size_mem sz)-1) p c1)
-(getN (ztonat(size_mem sz)-1) (p + delta) c2)).
-induction sz; assert (lo<= p< hi); simpl in H1; try omega;
-apply getN_inject with lo hi; try assumption; simpl ; try omega.
-induction sz ; simpl; inversion H2; auto.
-Qed.
-
-Hint Resolve load_contents_inject.
-
-Lemma load_result_inject:
- forall chunk v1 v2,
- val_content_inject (mem_chunk chunk) v1 v2 ->
- val_inject (Val.load_result chunk v1) (Val.load_result chunk v2).
-Proof.
-intros.
-destruct chunk; simpl in H; inversion H; simpl; auto;
-try (inversion H0; simpl; auto; fail).
-replace (Int.cast8signed n2) with (Int.cast8signed n1). constructor.
-apply Int.cast8_signed_equal_if_unsigned_equal; auto.
-rewrite H0; constructor.
-replace (Int.cast16signed n2) with (Int.cast16signed n1). constructor.
-apply Int.cast16_signed_equal_if_unsigned_equal; auto.
-rewrite H0; constructor.
-inversion H0; simpl; auto.
-apply val_inject_ptr with x; auto.
-Qed.
-
-Lemma in_bounds_inject:
- forall chunk c1 c2 delta p,
- block_contents_inject c1 c2 delta ->
- c1.(low) <= p /\ p + size_chunk chunk <= c1.(high) ->
- c2.(low) <= p + delta /\ (p + delta) + size_chunk chunk <= c2.(high).
+Lemma valid_pointer_inject:
+ forall f m1 m2 b ofs b' ofs',
+ mem_inject f m1 m2 ->
+ valid_pointer m1 b (Int.signed ofs) = true ->
+ val_inject f (Vptr b ofs) (Vptr b' ofs') ->
+ valid_pointer m2 b' (Int.signed ofs') = true.
Proof.
- intros.
- inversion H.
- generalize (size_chunk_pos chunk); intro.
- assert (low c1 <= p + size_chunk chunk - 1 < high c1).
- omega.
- generalize (bci_lowhigh0 _ H2). intro.
- assert (low c1 <= p < high c1).
- omega.
- generalize (bci_lowhigh0 _ H4). intro.
- omega.
+ intros. inv H1.
+ exploit valid_pointer_inject_no_overflow; eauto. intro NOOV.
+ inv H. rewrite Int.add_signed. rewrite Int.signed_repr; auto.
+ rewrite Int.signed_repr; eauto.
+ eapply valid_pointer_inj; eauto.
Qed.
-Lemma block_cont_val:
-forall c1 c2 delta p sz,
-block_contents_inject c1 c2 delta ->
-c1.(low) <= p -> p + size_mem sz <= c1.(high) ->
- val_content_inject sz (load_contents sz c1.(contents) p)
- (load_contents sz c2.(contents) (p + delta)).
-Proof.
-intros.
-inversion H .
-apply load_contents_inject with c1.(low) c1.(high) ;assumption.
-Qed.
+(** Relation between injections and loads. *)
Lemma load_inject:
- forall m1 m2 chunk b1 ofs b2 delta v1,
- mem_inject m1 m2 ->
+ forall f m1 m2 chunk b1 ofs b2 delta v1,
+ mem_inject f m1 m2 ->
load chunk m1 b1 ofs = Some v1 ->
f b1 = Some (b2, delta) ->
- exists v2, load chunk m2 b2 (ofs + delta) = Some v2 /\ val_inject v1 v2.
+ exists v2, load chunk m2 b2 (ofs + delta) = Some v2 /\ val_inject f v1 v2.
Proof.
- intros.
- generalize (load_inv _ _ _ _ _ H0). intros [A [B [C D]]].
- inversion H.
- generalize (mi_mappedblocks0 _ _ _ H1). intros [U V].
- inversion V.
- exists (Val.load_result chunk (load_contents (mem_chunk chunk)
- (m2.(blocks) b2).(contents) (ofs+delta))).
- split.
- unfold load.
- generalize (size_chunk_pos chunk); intro.
- rewrite zlt_true. rewrite in_bounds_holds. auto.
- assert (low (blocks m1 b1) <= ofs < high (blocks m1 b1)).
- omega.
- generalize (bci_lowhigh0 _ H3). tauto.
- assert (low (blocks m1 b1) <= ofs + size_chunk chunk - 1 < high(blocks m1 b1)).
- omega.
- generalize (bci_lowhigh0 _ H3). omega.
- assumption.
- rewrite <- D. apply load_result_inject.
- eapply load_contents_inject; eauto.
+ intros. inversion H.
+ eapply mi_inj0; eauto.
Qed.
Lemma loadv_inject:
- forall m1 m2 chunk a1 a2 v1,
- mem_inject m1 m2 ->
+ forall f m1 m2 chunk a1 a2 v1,
+ mem_inject f m1 m2 ->
loadv chunk m1 a1 = Some v1 ->
- val_inject a1 a2 ->
- exists v2, loadv chunk m2 a2 = Some v2 /\ val_inject v1 v2.
+ val_inject f a1 a2 ->
+ exists v2, loadv chunk m2 a2 = Some v2 /\ val_inject f v1 v2.
Proof.
- intros.
- induction H1 ; simpl in H0 ; try discriminate H0.
- simpl.
- replace (Int.signed ofs2) with (Int.signed ofs1 + x).
- apply load_inject with m1 b1 ; assumption.
- symmetry. generalize (load_inv _ _ _ _ _ H0). intros [A [B [C D]]].
- apply address_inject with m1 m2 chunk b1 b2; auto.
+ intros. inv H1; simpl in H0; try discriminate.
+ exploit load_inject; eauto. intros [v2 [LOAD INJ]].
+ exists v2; split; auto. simpl.
+ replace (Int.signed (Int.add ofs1 (Int.repr x)))
+ with (Int.signed ofs1 + x).
+ auto. symmetry. eapply address_inject; eauto with mem.
Qed.
(** Relation between injections and stores. *)
-Lemma set_cont_inject:
- forall c1 c2 lo hi delta,
- contentmap_inject c1 c2 lo hi delta ->
- forall n p,
- lo <= p -> p + Z_of_nat n <= hi ->
- contentmap_inject (set_cont n p c1) (set_cont n (p + delta) c2) lo hi delta.
-Proof.
-induction n. intros. simpl. assumption.
-intros. simpl. unfold contentmap_inject.
-intros p2 Hp2. unfold update.
-case (zeq p2 p); intro.
-subst p2. rewrite zeq_true. constructor.
-rewrite zeq_false. replace (p + delta + 1) with ((p + 1) + delta).
-apply IHn. omega. rewrite inj_S in H1. omega. assumption.
-omega. omega.
-Qed.
-
-Lemma setN_inject:
- forall c1 c2 lo hi delta n p v1 v2,
- contentmap_inject c1 c2 lo hi delta ->
- content_inject v1 v2 ->
- lo <= p -> p + Z_of_nat n < hi ->
- contentmap_inject (setN n p v1 c1) (setN n (p + delta) v2 c2)
- lo hi delta.
-Proof.
- intros. unfold setN. red; intros.
- unfold update.
- case (zeq x p); intro.
- subst p. rewrite zeq_true. assumption.
- rewrite zeq_false.
- replace (p + delta + 1) with ((p + 1) + delta).
- apply set_cont_inject with lo hi.
- assumption. omega. omega. assumption. omega.
- omega.
-Qed.
-
-Lemma store_contents_inject:
- forall c1 c2 lo hi delta sz p v1 v2,
- contentmap_inject c1 c2 lo hi delta ->
- val_content_inject sz v1 v2 ->
- lo <= p -> p + size_mem sz <= hi ->
- contentmap_inject (store_contents sz c1 p v1)
- (store_contents sz c2 (p + delta) v2)
- lo hi delta.
-Proof.
- intros.
- destruct sz; simpl in *; apply setN_inject; auto; simpl; omega.
-Qed.
-
-Lemma set_cont_outside1 :
- forall n p m q ,
- (forall x , p <= x < p + Z_of_nat n -> x <> q) ->
- (set_cont n p m) q = m q.
-Proof.
- induction n; intros; simpl.
- auto.
- rewrite inj_S in H. rewrite update_o. apply IHn.
- intros. apply H. omega.
- apply H. omega.
-Qed.
-
-Lemma set_cont_outside_inject:
- forall c1 c2 lo hi delta,
- contentmap_inject c1 c2 lo hi delta ->
- forall n p,
- (forall x1 x2, p <= x1 < p + Z_of_nat n ->
- lo <= x2 < hi ->
- x1 <> x2 + delta) ->
- contentmap_inject c1 (set_cont n p c2) lo hi delta.
-Proof.
- unfold contentmap_inject. intros.
- rewrite set_cont_outside1. apply H. assumption.
- intros. apply H0. auto. auto.
-Qed.
-
-Lemma setN_outside_inject:
- forall n c1 c2 lo hi delta p v,
- contentmap_inject c1 c2 lo hi delta ->
- (forall x1 x2, p <= x1 < p + Z_of_nat (S n) ->
- lo <= x2 < hi ->
- x1 <> x2 + delta) ->
- contentmap_inject c1 (setN n p v c2) lo hi delta.
-Proof.
- intros. unfold setN. red; intros. rewrite update_o.
- apply set_cont_outside_inject with lo hi. auto.
- intros. apply H0. rewrite inj_S. omega. auto. auto.
- apply H0. rewrite inj_S. omega. auto.
-Qed.
+Inductive val_content_inject (f: meminj): memory_chunk -> val -> val -> Prop :=
+ | val_content_inject_base:
+ forall chunk v1 v2,
+ val_inject f v1 v2 ->
+ val_content_inject f chunk v1 v2
+ | val_content_inject_8:
+ forall chunk n1 n2,
+ chunk = Mint8unsigned \/ chunk = Mint8signed ->
+ Int.cast8unsigned n1 = Int.cast8unsigned n2 ->
+ val_content_inject f chunk (Vint n1) (Vint n2)
+ | val_content_inject_16:
+ forall chunk n1 n2,
+ chunk = Mint16unsigned \/ chunk = Mint16signed ->
+ Int.cast16unsigned n1 = Int.cast16unsigned n2 ->
+ val_content_inject f chunk (Vint n1) (Vint n2)
+ | val_content_inject_32:
+ forall f1 f2,
+ Float.singleoffloat f1 = Float.singleoffloat f2 ->
+ val_content_inject f Mfloat32 (Vfloat f1) (Vfloat f2).
-Lemma store_contents_outside_inject:
- forall c1 c2 lo hi delta sz p v,
- contentmap_inject c1 c2 lo hi delta ->
- (forall x1 x2, p <= x1 < p + size_mem sz ->
- lo <= x2 < hi ->
- x1 <> x2 + delta)->
- contentmap_inject c1 (store_contents sz c2 p v) lo hi delta.
-Proof.
- intros c1 c2 lo hi delta sz. generalize (size_mem_pos sz) . intro .
- induction sz ;intros ;simpl ; apply setN_outside_inject ; assumption .
-Qed.
+Hint Resolve val_content_inject_base.
-Lemma store_mapped_inject_1:
- forall chunk m1 b1 ofs v1 n1 m2 b2 delta v2,
- mem_inject m1 m2 ->
+Lemma load_result_inject:
+ forall f chunk v1 v2 chunk',
+ val_content_inject f chunk v1 v2 ->
+ size_chunk chunk = size_chunk chunk' ->
+ val_inject f (Val.load_result chunk' v1) (Val.load_result chunk' v2).
+Proof.
+ intros. inv H; simpl.
+ inv H1; destruct chunk'; simpl; econstructor; eauto.
+
+ elim H1; intro; subst chunk;
+ destruct chunk'; simpl in H0; try discriminate; simpl.
+ replace (Int.cast8signed n1) with (Int.cast8signed n2).
+ constructor. apply Int.cast8_signed_equal_if_unsigned_equal; auto.
+ rewrite H2. constructor.
+ replace (Int.cast8signed n1) with (Int.cast8signed n2).
+ constructor. apply Int.cast8_signed_equal_if_unsigned_equal; auto.
+ rewrite H2. constructor.
+
+ elim H1; intro; subst chunk;
+ destruct chunk'; simpl in H0; try discriminate; simpl.
+ replace (Int.cast16signed n1) with (Int.cast16signed n2).
+ constructor. apply Int.cast16_signed_equal_if_unsigned_equal; auto.
+ rewrite H2. constructor.
+ replace (Int.cast16signed n1) with (Int.cast16signed n2).
+ constructor. apply Int.cast16_signed_equal_if_unsigned_equal; auto.
+ rewrite H2. constructor.
+
+ destruct chunk'; simpl in H0; try discriminate; simpl.
+ constructor. rewrite H1; constructor.
+Qed.
+
+Lemma store_mapped_inject_1 :
+ forall f chunk m1 b1 ofs v1 n1 m2 b2 delta v2,
+ mem_inject f m1 m2 ->
store chunk m1 b1 ofs v1 = Some n1 ->
f b1 = Some (b2, delta) ->
- val_content_inject (mem_chunk chunk) v1 v2 ->
+ val_content_inject f chunk v1 v2 ->
exists n2,
store chunk m2 b2 (ofs + delta) v2 = Some n2
- /\ mem_inject n1 n2.
-Proof.
-intros.
-generalize (size_chunk_pos chunk); intro SIZEPOS.
-generalize (store_inv _ _ _ _ _ _ H0).
-intros [A [B [C [D [P E]]]]].
-inversion H.
-generalize (mi_mappedblocks0 _ _ _ H1). intros [U V].
-inversion V.
-generalize (in_bounds_inject _ _ _ _ _ V (conj B C)). intro BND.
-exists (unchecked_store chunk m2 b2 (ofs+delta) v2 BND).
-split. unfold store.
-rewrite zlt_true; auto.
-case (in_bounds chunk (ofs + delta) (blocks m2 b2)); intro.
-assert (a = BND). apply proof_irrelevance. congruence.
-omegaContradiction.
-constructor.
-intros. apply mi_freeblocks0. rewrite <- D. assumption.
-intros. generalize (mi_mappedblocks0 b b' delta0 H3).
-intros [W Y]. split. simpl. auto.
-rewrite E; simpl. unfold update.
-(* Cas 1: memes blocs b = b1 b'= b2 *)
-case (zeq b b1); intro.
-subst b. assert (b'= b2). congruence. subst b'.
-assert (delta0 = delta). congruence. subst delta0.
-rewrite zeq_true. inversion Y. constructor; simpl; auto.
-apply store_contents_inject; auto.
-(* Cas 2: blocs differents dans m1 mais mappes sur le meme bloc de m2 *)
-case (zeq b' b2); intro.
-subst b'.
-inversion Y. constructor; simpl; auto.
-generalize (store_contents_outside_inject _ _ _ _ _ (mem_chunk chunk)
- (ofs+delta) v2 bci_contents1).
-intros.
-apply H4.
-elim (mi_no_overlap0 b b1 b2 b2 delta0 delta n H3 H1).
-tauto.
-unfold high_bound, low_bound. intros.
-apply sym_not_equal. replace x1 with ((x1 - delta) + delta).
-apply H5. assumption. unfold size_chunk in C. omega. omega.
-(* Cas 3: blocs differents dans m1 et dans m2 *)
-auto.
-
-unfold high_bound, low_bound.
-rewrite E; simpl; intros.
-unfold high_bound, low_bound in mi_no_overlap0.
-unfold update.
-case (zeq b0 b1).
-intro. subst b1. simpl.
-rewrite zeq_false; auto.
-intro. case (zeq b3 b1); intro.
-subst b3. simpl. auto.
-auto.
+ /\ mem_inject f n1 n2.
+Proof.
+ intros. inversion H.
+ exploit store_mapped_inj; eauto.
+ intros; constructor.
+ intros. apply load_result_inject with chunk; eauto.
+ intros [n2 [STORE MINJ]].
+ exists n2; split. auto. constructor.
+ (* inj *)
+ auto.
+ (* freeblocks *)
+ intros. apply mi_freeblocks0. red; intro. elim H3. eauto with mem.
+ (* mappedblocks *)
+ intros. eauto with mem.
+ (* no_overlap *)
+ red; intros.
+ repeat rewrite (low_bound_store _ _ _ _ _ _ H0).
+ repeat rewrite (high_bound_store _ _ _ _ _ _ H0).
+ eapply mi_no_overlap0; eauto.
+ (* range *)
+ auto.
+ intros.
+ repeat rewrite (low_bound_store _ _ _ _ _ _ STORE).
+ repeat rewrite (high_bound_store _ _ _ _ _ _ STORE).
+ eapply mi_range_4; eauto.
Qed.
Lemma store_mapped_inject:
- forall chunk m1 b1 ofs v1 n1 m2 b2 delta v2,
- mem_inject m1 m2 ->
+ forall f chunk m1 b1 ofs v1 n1 m2 b2 delta v2,
+ mem_inject f m1 m2 ->
store chunk m1 b1 ofs v1 = Some n1 ->
f b1 = Some (b2, delta) ->
- val_inject v1 v2 ->
+ val_inject f v1 v2 ->
exists n2,
store chunk m2 b2 (ofs + delta) v2 = Some n2
- /\ mem_inject n1 n2.
+ /\ mem_inject f n1 n2.
Proof.
intros. eapply store_mapped_inject_1; eauto.
Qed.
Lemma store_unmapped_inject:
- forall chunk m1 b1 ofs v1 n1 m2,
- mem_inject m1 m2 ->
+ forall f chunk m1 b1 ofs v1 n1 m2,
+ mem_inject f m1 m2 ->
store chunk m1 b1 ofs v1 = Some n1 ->
f b1 = None ->
- mem_inject n1 m2.
-Proof.
-intros.
-inversion H.
-generalize (store_inv _ _ _ _ _ _ H0).
-intros [A [B [C [D [P E]]]]].
-constructor.
-rewrite D. assumption.
-intros. elim (mi_mappedblocks0 _ _ _ H2); intros.
-split. auto.
-rewrite E; unfold update.
-rewrite zeq_false. assumption.
-congruence.
-intros.
-assert (forall b, low_bound n1 b = low_bound m1 b).
- intros. unfold low_bound; rewrite E; unfold update.
- case (zeq b b1); intros. subst b1; reflexivity. reflexivity.
-assert (forall b, high_bound n1 b = high_bound m1 b).
- intros. unfold high_bound; rewrite E; unfold update.
- case (zeq b b1); intros. subst b1; reflexivity. reflexivity.
-repeat rewrite H5. repeat rewrite H6. auto.
+ mem_inject f n1 m2.
+Proof.
+ intros. inversion H.
+ constructor.
+ (* inj *)
+ eapply store_unmapped_inj; eauto.
+ (* freeblocks *)
+ intros. apply mi_freeblocks0. red; intros; elim H2; eauto with mem.
+ (* mappedblocks *)
+ intros. eapply mi_mappedblocks0; eauto with mem.
+ (* no_overlap *)
+ red; intros.
+ repeat rewrite (low_bound_store _ _ _ _ _ _ H0).
+ repeat rewrite (high_bound_store _ _ _ _ _ _ H0).
+ eapply mi_no_overlap0; eauto.
+ (* range *)
+ auto. auto.
Qed.
Lemma storev_mapped_inject_1:
- forall chunk m1 a1 v1 n1 m2 a2 v2,
- mem_inject m1 m2 ->
+ forall f chunk m1 a1 v1 n1 m2 a2 v2,
+ mem_inject f m1 m2 ->
storev chunk m1 a1 v1 = Some n1 ->
- val_inject a1 a2 ->
- val_content_inject (mem_chunk chunk) v1 v2 ->
+ val_inject f a1 a2 ->
+ val_content_inject f chunk v1 v2 ->
exists n2,
- storev chunk m2 a2 v2 = Some n2 /\ mem_inject n1 n2.
+ storev chunk m2 a2 v2 = Some n2 /\ mem_inject f n1 n2.
Proof.
- intros. destruct a1; simpl in H0; try discriminate.
- inversion H1. subst b.
- simpl. replace (Int.signed ofs2) with (Int.signed i + x).
+ intros. inv H1; simpl in H0; try discriminate.
+ simpl. replace (Int.signed (Int.add ofs1 (Int.repr x)))
+ with (Int.signed ofs1 + x).
eapply store_mapped_inject_1; eauto.
- symmetry. generalize (store_inv _ _ _ _ _ _ H0). intros [A [B [C [D [P E]]]]].
- apply address_inject with m1 m2 chunk b1 b2; auto.
+ symmetry. eapply address_inject; eauto with mem.
Qed.
Lemma storev_mapped_inject:
- forall chunk m1 a1 v1 n1 m2 a2 v2,
- mem_inject m1 m2 ->
+ forall f chunk m1 a1 v1 n1 m2 a2 v2,
+ mem_inject f m1 m2 ->
storev chunk m1 a1 v1 = Some n1 ->
- val_inject a1 a2 ->
- val_inject v1 v2 ->
+ val_inject f a1 a2 ->
+ val_inject f v1 v2 ->
exists n2,
- storev chunk m2 a2 v2 = Some n2 /\ mem_inject n1 n2.
+ storev chunk m2 a2 v2 = Some n2 /\ mem_inject f n1 n2.
Proof.
intros. eapply storev_mapped_inject_1; eauto.
Qed.
(** Relation between injections and [free] *)
-Lemma free_first_inject :
- forall m1 m2 b,
- mem_inject m1 m2 ->
- mem_inject (free m1 b) m2.
-Proof.
- intros. inversion H. constructor . auto.
- simpl. intros.
- generalize (mi_mappedblocks0 b0 b' delta H0).
- intros [A B] . split. assumption . unfold update.
- case (zeq b0 b); intro. inversion B. constructor; simpl; auto.
- intros. omega.
- unfold contentmap_inject.
- intros. omegaContradiction.
- auto. intros.
- unfold free . unfold low_bound , high_bound. simpl. unfold update.
- case (zeq b1 b);intro. simpl.
- right. intros. omegaContradiction.
- case (zeq b2 b);intro. simpl.
- right . intros. omegaContradiction.
- unfold low_bound, high_bound in mi_no_overlap0. auto.
-Qed.
-
-Lemma free_first_list_inject :
- forall l m1 m2,
- mem_inject m1 m2 ->
- mem_inject (free_list m1 l) m2.
-Proof.
- induction l; simpl; intros.
- auto.
- apply free_first_inject. auto.
-Qed.
-
-Lemma free_snd_inject:
- forall m1 m2 b,
- (forall b1 delta, f b1 = Some(b, delta) ->
- low_bound m1 b1 >= high_bound m1 b1) ->
- mem_inject m1 m2 ->
- mem_inject m1 (free m2 b).
-Proof.
- intros. inversion H0. constructor. auto.
- simpl. intros.
- generalize (mi_mappedblocks0 b0 b' delta H1).
- intros [A B] . split. assumption .
- inversion B. unfold update.
- case (zeq b' b); intro.
- subst b'. generalize (H _ _ H1). unfold low_bound, high_bound; intro.
- constructor. auto. elim bci_range4 ; intro.
- (**delta=0**)
- left ; auto .
- (** delta<>0**)
- right .
- simpl. compute. split; intro; congruence.
- intros. omegaContradiction.
- red; intros. omegaContradiction.
- auto.
- auto.
-Qed.
-
-Lemma bounds_free_block:
- forall m1 b m1' , free m1 b = m1' ->
- low_bound m1' b >= high_bound m1' b.
+Lemma meminj_no_overlap_free:
+ forall mi m b,
+ meminj_no_overlap mi m ->
+ meminj_no_overlap mi (free m b).
Proof.
- intros. unfold free in H.
- rewrite<- H . unfold low_bound , high_bound .
- simpl . rewrite update_s. simpl. omega.
+ intros; red; intros.
+ assert (low_bound (free m b) b >= high_bound (free m b) b).
+ rewrite low_bound_free_same; rewrite high_bound_free_same; auto.
+ omega.
+ destruct (eq_block b1 b); destruct (eq_block b2 b); subst; auto.
+ repeat (rewrite low_bound_free; auto).
+ repeat (rewrite high_bound_free; auto).
Qed.
-Lemma free_empty_bounds:
- forall l m1 ,
- let m1' := free_list m1 l in
- (forall b, In b l -> low_bound m1' b >= high_bound m1' b).
+Lemma meminj_no_overlap_free_list:
+ forall mi m bl,
+ meminj_no_overlap mi m ->
+ meminj_no_overlap mi (free_list m bl).
Proof.
- induction l . intros . inversion H.
- intros.
- generalize (in_inv H).
- intro . elim H0. intro . subst b. simpl in m1' .
- generalize ( bounds_free_block
- (fold_right (fun (b : block) (m : mem) => free m b) m1 l) a m1') .
- intros. apply H1. auto . intros. simpl in m1'. unfold m1' .
- unfold low_bound , high_bound . simpl .
- unfold update; case (zeq b a); intro; simpl.
- omega .
- unfold low_bound , high_bound in IHl . auto.
-Qed.
+ induction bl; simpl; intros. auto.
+ apply meminj_no_overlap_free. auto.
+Qed.
Lemma free_inject:
- forall m1 m2 l b,
+ forall f m1 m2 l b,
(forall b1 delta, f b1 = Some(b, delta) -> In b1 l) ->
- mem_inject m1 m2 ->
- mem_inject (free_list m1 l) (free m2 b).
-Proof.
- intros. apply free_snd_inject.
- intros. apply free_empty_bounds. apply H with delta. auto.
- apply free_first_list_inject. auto.
-Qed.
-
-Lemma contents_init_data_inject:
- forall id, contentmap_inject (contents_init_data 0 id) (contents_init_data 0 id) 0 (size_init_data_list id) 0.
-Proof.
- intro id0.
- set (sz0 := size_init_data_list id0).
- assert (forall id pos,
- 0 <= pos -> pos + size_init_data_list id <= sz0 ->
- contentmap_inject (contents_init_data pos id) (contents_init_data pos id) 0 sz0 0).
- induction id; simpl; intros.
- red; intros; constructor.
- assert (forall n dt,
- size_init_data a = 1 + Z_of_nat n ->
- content_inject dt dt ->
- contentmap_inject (setN n pos dt (contents_init_data (pos + size_init_data a) id))
- (setN n pos dt (contents_init_data (pos + size_init_data a) id))
- 0 sz0 0).
- intros. set (pos' := pos) in |- * at 3. replace pos' with (pos + 0).
- apply setN_inject. apply IHid. omega. omega. auto. auto.
- generalize (size_init_data_list_pos id). omega. unfold pos'; omega.
- destruct a;
- try (apply H1; [reflexivity|repeat constructor]).
- apply IHid. generalize (Zmax2 z 0). omega. simpl in H0; omega.
- apply IHid. omega. simpl size_init_data in H0. omega.
- apply H. omega. unfold sz0. omega.
-Qed.
-
-End MEM_INJECT.
-
-Hint Resolve val_inject_int val_inject_float val_inject_ptr val_inject_undef.
-Hint Resolve val_nil_inject val_cons_inject.
+ mem_inject f m1 m2 ->
+ mem_inject f (free_list m1 l) (free m2 b).
+Proof.
+ intros. inversion H0. constructor.
+ (* inj *)
+ apply free_right_inj. apply free_list_left_inj. auto.
+ intros; red; intros.
+ elim (valid_access_free_list_inv _ _ _ _ _ H2); intros.
+ elim H3; eauto.
+ (* freeblocks *)
+ intros. apply mi_freeblocks0. red; intro; elim H1.
+ apply valid_block_free_list_1; auto.
+ (* mappedblocks *)
+ intros. apply valid_block_free_1. eauto.
+ (* overlap *)
+ apply meminj_no_overlap_free_list; auto.
+ (* range *)
+ auto.
+ intros. destruct (eq_block b' b). subst b'.
+ rewrite low_bound_free_same; rewrite high_bound_free_same.
+ right; compute; intuition congruence.
+ rewrite low_bound_free; auto. rewrite high_bound_free; auto.
+ eauto.
+Qed.
(** Monotonicity properties of memory injections. *)
@@ -2160,16 +2100,11 @@ Lemma inject_incr_refl :
Proof. unfold inject_incr . intros. left . auto . Qed.
Lemma inject_incr_trans :
- forall f1 f2 f3 ,
+ forall f1 f2 f3,
inject_incr f1 f2 -> inject_incr f2 f3 -> inject_incr f1 f3 .
Proof .
- unfold inject_incr . intros .
- generalize (H b) . intro . generalize (H0 b) . intro .
- elim H1 ; elim H2 ; intros.
- rewrite H3 in H4 . left . auto .
- rewrite H3 in H4 . right . auto .
- right ; auto .
- right ; auto .
+ unfold inject_incr; intros.
+ generalize (H b); generalize (H0 b); intuition congruence.
Qed.
Lemma val_inject_incr:
@@ -2192,61 +2127,17 @@ Lemma val_list_inject_incr:
inject_incr f1 f2 -> val_list_inject f1 vl vl' ->
val_list_inject f2 vl vl'.
Proof.
- induction vl ; intros; inversion H0. auto .
- subst a . generalize (val_inject_incr f1 f2 v v' H H3) .
- intro . auto .
-Qed.
-
-Hint Resolve inject_incr_refl val_inject_incr val_list_inject_incr.
-
-Section MEM_INJECT_INCR.
-
-Variable f1 f2: meminj.
-Hypothesis INCR: inject_incr f1 f2.
-
-Lemma val_content_inject_incr:
- forall chunk v v',
- val_content_inject f1 chunk v v' ->
- val_content_inject f2 chunk v v'.
-Proof.
- intros. inversion H.
- apply val_content_inject_base. eapply val_inject_incr; eauto.
- apply val_content_inject_8; auto.
- apply val_content_inject_16; auto.
- apply val_content_inject_32; auto.
+ induction vl; intros; inv H0. auto.
+ constructor. eapply val_inject_incr; eauto. auto.
Qed.
-Lemma content_inject_incr:
- forall c c', content_inject f1 c c' -> content_inject f2 c c'.
-Proof.
- induction 1; constructor; eapply val_content_inject_incr; eauto.
-Qed.
-
-Lemma contentmap_inject_incr:
- forall c c' lo hi delta,
- contentmap_inject f1 c c' lo hi delta ->
- contentmap_inject f2 c c' lo hi delta.
-Proof.
- unfold contentmap_inject; intros.
- apply content_inject_incr. auto.
-Qed.
-
-Lemma block_contents_inject_incr:
- forall c c' delta,
- block_contents_inject f1 c c' delta ->
- block_contents_inject f2 c c' delta.
-Proof.
- intros. inversion H. constructor; auto.
- apply contentmap_inject_incr; auto.
-Qed.
-
-End MEM_INJECT_INCR.
+Hint Resolve inject_incr_refl val_inject_incr val_list_inject_incr.
(** Properties of injections and allocations. *)
Definition extend_inject
(b: block) (x: option (block * Z)) (f: meminj) : meminj :=
- fun b' => if eq_block b' b then x else f b'.
+ fun (b': block) => if zeq b' b then x else f b'.
Lemma extend_inject_incr:
forall f b x,
@@ -2254,7 +2145,7 @@ Lemma extend_inject_incr:
inject_incr f (extend_inject b x f).
Proof.
intros; red; intros. unfold extend_inject.
- case (eq_block b0 b); intro. subst b0. right; auto. left; auto.
+ destruct (zeq b0 b). subst b0; auto. auto.
Qed.
Lemma alloc_right_inject:
@@ -2263,14 +2154,17 @@ Lemma alloc_right_inject:
alloc m2 lo hi = (m2', b) ->
mem_inject f m1 m2'.
Proof.
- intros. unfold alloc in H0. injection H0; intros A B; clear H0.
- inversion H.
- constructor.
- assumption.
- intros. generalize (mi_mappedblocks0 _ _ _ H0). intros [C D].
- rewrite <- B; simpl. split. omega.
- rewrite update_o. auto. omega.
- assumption.
+ intros. inversion H. constructor.
+ eapply alloc_right_inj; eauto.
+ auto.
+ intros. eauto with mem.
+ auto.
+ auto.
+ intros. replace (low_bound m2' b') with (low_bound m2 b').
+ replace (high_bound m2' b') with (high_bound m2 b').
+ eauto.
+ symmetry. eapply high_bound_alloc_other; eauto.
+ symmetry. eapply low_bound_alloc_other; eauto.
Qed.
Lemma alloc_unmapped_inject:
@@ -2280,26 +2174,36 @@ Lemma alloc_unmapped_inject:
mem_inject (extend_inject b None f) m1' m2 /\
inject_incr f (extend_inject b None f).
Proof.
- intros. unfold alloc in H0. injection H0; intros; clear H0.
- inversion H.
+ intros. inversion H.
assert (inject_incr f (extend_inject b None f)).
- apply extend_inject_incr. apply mi_freeblocks0. rewrite H1. omega.
- split; auto.
- constructor.
- rewrite <- H2; simpl; intros. unfold extend_inject.
- case (eq_block b0 b); intro. auto. apply mi_freeblocks0. omega.
- intros until delta. unfold extend_inject at 1. case (eq_block b0 b); intro.
- intros; discriminate.
- intros. rewrite <- H2; simpl. rewrite H1.
- rewrite update_o; auto.
- elim (mi_mappedblocks0 _ _ _ H3). intros A B.
- split. auto. apply block_contents_inject_incr with f. auto. auto.
- intros until delta2. unfold extend_inject.
- case (eq_block b1 b); intro. congruence.
- case (eq_block b2 b); intro. congruence.
- rewrite <- H2. unfold low_bound, high_bound; simpl. rewrite H1.
- repeat rewrite update_o; auto.
- exact (mi_no_overlap0 b1 b2 b1' b2' delta1 delta2).
+ apply extend_inject_incr. apply mi_freeblocks0. eauto with mem.
+ split; auto. constructor.
+ (* inj *)
+ eapply alloc_left_unmapped_inj; eauto.
+ red; intros. unfold extend_inject in H2.
+ destruct (zeq b1 b). congruence.
+ exploit mi_inj0; eauto. intros [v2 [LOAD VINJ]].
+ exists v2; split. auto.
+ apply val_inject_incr with f; auto.
+ unfold extend_inject. apply zeq_true.
+ (* freeblocks *)
+ intros. unfold extend_inject. destruct (zeq b0 b). auto.
+ apply mi_freeblocks0; red; intro. elim H2. eauto with mem.
+ (* mappedblocks *)
+ intros. unfold extend_inject in H2. destruct (zeq b0 b).
+ discriminate. eauto.
+ (* overlap *)
+ red; unfold extend_inject, update; intros.
+ repeat rewrite (low_bound_alloc _ _ _ _ _ H0).
+ repeat rewrite (high_bound_alloc _ _ _ _ _ H0).
+ destruct (zeq b1 b); try discriminate.
+ destruct (zeq b2 b); try discriminate.
+ eauto.
+ (* range *)
+ unfold extend_inject; intros.
+ destruct (zeq b0 b). discriminate. eauto.
+ unfold extend_inject; intros.
+ destruct (zeq b0 b). discriminate. eauto.
Qed.
Lemma alloc_mapped_inject:
@@ -2319,50 +2223,41 @@ Lemma alloc_mapped_inject:
mem_inject (extend_inject b (Some (b', ofs)) f) m1' m2 /\
inject_incr f (extend_inject b (Some (b', ofs)) f).
Proof.
- intros.
- generalize (fun b' => low_bound_alloc _ _ b' _ _ _ H0).
- intro LOW.
- generalize (fun b' => high_bound_alloc _ _ b' _ _ _ H0).
- intro HIGH.
- unfold alloc in H0. injection H0; intros A B; clear H0.
- inversion H.
- (* inject_incr *)
+ intros. inversion H.
assert (inject_incr f (extend_inject b (Some (b', ofs)) f)).
- apply extend_inject_incr. apply mi_freeblocks0. rewrite A. omega.
+ apply extend_inject_incr. apply mi_freeblocks0. eauto with mem.
split; auto.
constructor.
- (* mi_freeblocks *)
- rewrite <- B; simpl; intros. unfold extend_inject.
- case (eq_block b0 b); intro. unfold block in *. omegaContradiction.
- apply mi_freeblocks0. omega.
- (* mi_mappedblocks *)
- intros until delta. unfold extend_inject at 1.
- case (eq_block b0 b); intro.
- intros. subst b0. inversion H8. subst b'0; subst delta.
- split. assumption.
- rewrite <- B; simpl. rewrite A. rewrite update_s.
- constructor; auto.
- unfold empty_block. simpl. intros. unfold low_bound in H5. unfold high_bound in H6. omega.
- simpl. red; intros. constructor.
- intros.
- generalize (mi_mappedblocks0 _ _ _ H8). intros [C D].
- split. auto.
- rewrite <- B; simpl; rewrite A; rewrite update_o; auto.
- apply block_contents_inject_incr with f; auto.
- (* no overlap *)
- intros until delta2. unfold extend_inject.
- repeat rewrite LOW. repeat rewrite HIGH. unfold eq_block.
- case (zeq b1 b); case (zeq b2 b); intros.
- congruence.
- inversion H9. subst b1'; subst delta1.
- case (eq_block b' b2'); intro.
- subst b2'. generalize (H7 _ _ H10). intro.
- right. intros. omega. left. auto.
- inversion H10. subst b2'; subst delta2.
- case (eq_block b' b1'); intro.
- subst b1'. generalize (H7 _ _ H9). intro.
- right. intros. omega. left. auto.
- apply mi_no_overlap0; auto.
+ (* inj *)
+ eapply alloc_left_mapped_inj; eauto.
+ red; intros. unfold extend_inject in H9.
+ rewrite zeq_false in H9.
+ exploit mi_inj0; eauto. intros [v2 [LOAD VINJ]].
+ exists v2; split. auto. eapply val_inject_incr; eauto.
+ eauto with mem.
+ unfold extend_inject. apply zeq_true.
+ (* freeblocks *)
+ intros. unfold extend_inject. rewrite zeq_false.
+ apply mi_freeblocks0. red; intro. elim H9; eauto with mem.
+ apply sym_not_equal; eauto with mem.
+ (* mappedblocks *)
+ unfold extend_inject; intros.
+ destruct (zeq b0 b). inv H9. auto. eauto.
+ (* overlap *)
+ red; unfold extend_inject, update; intros.
+ repeat rewrite (low_bound_alloc _ _ _ _ _ H0).
+ repeat rewrite (high_bound_alloc _ _ _ _ _ H0).
+ destruct (zeq b1 b); [inv H10|idtac];
+ (destruct (zeq b2 b); [inv H11|idtac]).
+ congruence.
+ destruct (zeq b1' b2'). subst b2'. generalize (H7 _ _ H11). tauto. auto.
+ destruct (zeq b1' b2'). subst b2'. generalize (H7 _ _ H10). tauto. auto.
+ eauto.
+ (* range *)
+ unfold extend_inject; intros.
+ destruct (zeq b0 b). inv H9. auto. eauto.
+ unfold extend_inject; intros.
+ destruct (zeq b0 b). inv H9. auto. eauto.
Qed.
Lemma alloc_parallel_inject:
@@ -2371,20 +2266,104 @@ Lemma alloc_parallel_inject:
alloc m1 lo hi = (m1', b1) ->
alloc m2 lo hi = (m2', b2) ->
Int.min_signed <= lo -> hi <= Int.max_signed ->
- mem_inject (extend_inject b1 (Some(b2,0)) f) m1' m2' /\
- inject_incr f (extend_inject b1 (Some(b2,0)) f).
+ mem_inject (extend_inject b1 (Some(b2, 0)) f) m1' m2' /\
+ inject_incr f (extend_inject b1 (Some(b2, 0)) f).
Proof.
intros.
- generalize (low_bound_alloc _ _ b2 _ _ _ H1). rewrite zeq_true; intro LOW.
- generalize (high_bound_alloc _ _ b2 _ _ _ H1). rewrite zeq_true; intro HIGH.
eapply alloc_mapped_inject; eauto.
eapply alloc_right_inject; eauto.
- eapply valid_new_block; eauto.
- compute. intuition congruence.
- rewrite LOW; auto.
- rewrite HIGH; auto.
- rewrite LOW; omega.
- rewrite HIGH; omega.
- intros. elim (mi_mappedblocks _ _ _ H _ _ _ H4); intros.
- injection H1; intros. rewrite H7 in H5. omegaContradiction.
+ eauto with mem.
+ compute; intuition congruence.
+ rewrite (low_bound_alloc_same _ _ _ _ _ H1). auto.
+ rewrite (high_bound_alloc_same _ _ _ _ _ H1). auto.
+ rewrite (low_bound_alloc_same _ _ _ _ _ H1). omega.
+ rewrite (high_bound_alloc_same _ _ _ _ _ H1). omega.
+ intros. elimtype False. inv H.
+ exploit mi_mappedblocks0; eauto.
+ change (~ valid_block m2 b2). eauto with mem.
+Qed.
+
+Definition meminj_init (m: mem) : meminj :=
+ fun (b: block) => if zlt b m.(nextblock) then Some(b, 0) else None.
+
+Definition mem_inject_neutral (m: mem) : Prop :=
+ forall f chunk b ofs v,
+ load chunk m b ofs = Some v -> val_inject f v v.
+
+Lemma init_inject:
+ forall m,
+ mem_inject_neutral m ->
+ mem_inject (meminj_init m) m m.
+Proof.
+ intros; constructor.
+ (* inj *)
+ red; intros. unfold meminj_init in H0.
+ destruct (zlt b1 (nextblock m)); inversion H0.
+ subst b2 delta. exists v1; split.
+ rewrite Zplus_0_r. auto. eapply H; eauto.
+ (* free blocks *)
+ unfold valid_block, meminj_init; intros.
+ apply zlt_false. omega.
+ (* mapped blocks *)
+ unfold valid_block, meminj_init; intros.
+ destruct (zlt b (nextblock m)); inversion H0. subst b'; auto.
+ (* overlap *)
+ red; unfold meminj_init; intros.
+ destruct (zlt b1 (nextblock m)); inversion H1.
+ destruct (zlt b2 (nextblock m)); inversion H2.
+ left; congruence.
+ (* range *)
+ unfold meminj_init; intros.
+ destruct (zlt b (nextblock m)); inversion H0. subst delta.
+ compute; intuition congruence.
+ unfold meminj_init; intros.
+ destruct (zlt b (nextblock m)); inversion H0. subst delta.
+ auto.
+Qed.
+
+Remark getN_setN_inject:
+ forall f m v n1 p1 n2 p2,
+ val_inject f (getN n2 p2 m) (getN n2 p2 m) ->
+ val_inject f v v ->
+ val_inject f (getN n2 p2 (setN n1 p1 v m))
+ (getN n2 p2 (setN n1 p1 v m)).
+Proof.
+ intros.
+ destruct (getN_setN_characterization m v n1 p1 n2 p2)
+ as [A | [A | A]]; rewrite A; auto.
+Qed.
+
+Remark getN_contents_init_data_inject:
+ forall f n ofs id pos,
+ val_inject f (getN n ofs (contents_init_data pos id))
+ (getN n ofs (contents_init_data pos id)).
+Proof.
+ induction id; simpl; intros.
+ repeat rewrite getN_init. constructor.
+ destruct a; auto; apply getN_setN_inject; auto.
+Qed.
+
+Lemma alloc_init_data_neutral:
+ forall m id m' b,
+ mem_inject_neutral m ->
+ alloc_init_data m id = (m', b) ->
+ mem_inject_neutral m'.
+Proof.
+ intros. injection H0; intros A B.
+ red; intros.
+ exploit load_inv; eauto. intros [C D].
+ rewrite <- B in D; simpl in D. rewrite A in D.
+ unfold update in D. destruct (zeq b0 b).
+ subst b0. rewrite D. simpl.
+ apply load_result_inject with chunk. constructor.
+ apply getN_contents_init_data_inject. auto.
+ apply H with chunk b0 ofs. unfold load.
+ rewrite in_bounds_true. congruence.
+ inversion C. constructor.
+ generalize H2. unfold valid_block. rewrite <- B; simpl.
+ rewrite A. unfold block in n; intros. omega.
+ replace (low_bound m b0) with (low_bound m' b0). auto.
+ unfold low_bound; rewrite <- B; simpl; rewrite A. rewrite update_o; auto.
+ replace (high_bound m b0) with (high_bound m' b0). auto.
+ unfold high_bound; rewrite <- B; simpl; rewrite A. rewrite update_o; auto.
Qed.
diff --git a/common/Smallstep.v b/common/Smallstep.v
new file mode 100644
index 0000000000000000000000000000000000000000..7f6c776f804c9d053f3e9c17e466ff1cba8ff13b
--- /dev/null
+++ b/common/Smallstep.v
@@ -0,0 +1,460 @@
+(** Tools for small-step operational semantics *)
+
+(** This module defines generic operations and theorems over
+ the one-step transition relations that are used to specify
+ operational semantics in small-step style. *)
+
+Require Import Coqlib.
+Require Import AST.
+Require Import Events.
+Require Import Globalenvs.
+Require Import Integers.
+
+Set Implicit Arguments.
+
+(** * Closures of transitions relations *)
+
+Section CLOSURES.
+
+Variable genv: Set.
+Variable state: Set.
+
+(** A one-step transition relation has the following signature.
+ It is parameterized by a global environment, which does not
+ change during the transition. It relates the initial state
+ of the transition with its final state. The [trace] parameter
+ captures the observable events possibly generated during the
+ transition. *)
+
+Variable step: genv -> state -> trace -> state -> Prop.
+
+(** Zero, one or several transitions. Also known as Kleene closure,
+ or reflexive transitive closure. *)
+
+Inductive star (ge: genv): state -> trace -> state -> Prop :=
+ | star_refl: forall s,
+ star ge s E0 s
+ | star_step: forall s1 t1 s2 t2 s3 t,
+ step ge s1 t1 s2 -> star ge s2 t2 s3 -> t = t1 ** t2 ->
+ star ge s1 t s3.
+
+Lemma star_one:
+ forall ge s1 t s2, step ge s1 t s2 -> star ge s1 t s2.
+Proof.
+ intros. eapply star_step; eauto. apply star_refl. traceEq.
+Qed.
+
+Lemma star_trans:
+ forall ge s1 t1 s2, star ge s1 t1 s2 ->
+ forall t2 s3 t, star ge s2 t2 s3 -> t = t1 ** t2 -> star ge s1 t s3.
+Proof.
+ induction 1; intros.
+ rewrite H0. simpl. auto.
+ eapply star_step; eauto. traceEq.
+Qed.
+
+Lemma star_left:
+ forall ge s1 t1 s2 t2 s3 t,
+ step ge s1 t1 s2 -> star ge s2 t2 s3 -> t = t1 ** t2 ->
+ star ge s1 t s3.
+Proof star_step.
+
+Lemma star_right:
+ forall ge s1 t1 s2 t2 s3 t,
+ star ge s1 t1 s2 -> step ge s2 t2 s3 -> t = t1 ** t2 ->
+ star ge s1 t s3.
+Proof.
+ intros. eapply star_trans. eauto. apply star_one. eauto. auto.
+Qed.
+
+(** One or several transitions. Also known as the transitive closure. *)
+
+Inductive plus (ge: genv): state -> trace -> state -> Prop :=
+ | plus_left: forall s1 t1 s2 t2 s3 t,
+ step ge s1 t1 s2 -> star ge s2 t2 s3 -> t = t1 ** t2 ->
+ plus ge s1 t s3.
+
+Lemma plus_one:
+ forall ge s1 t s2,
+ step ge s1 t s2 -> plus ge s1 t s2.
+Proof.
+ intros. econstructor; eauto. apply star_refl. traceEq.
+Qed.
+
+Lemma plus_star:
+ forall ge s1 t s2, plus ge s1 t s2 -> star ge s1 t s2.
+Proof.
+ intros. inversion H; subst.
+ eapply star_step; eauto.
+Qed.
+
+Lemma plus_right:
+ forall ge s1 t1 s2 t2 s3 t,
+ star ge s1 t1 s2 -> step ge s2 t2 s3 -> t = t1 ** t2 ->
+ plus ge s1 t s3.
+Proof.
+ intros. inversion H; subst. simpl. apply plus_one. auto.
+ rewrite Eapp_assoc. eapply plus_left; eauto.
+ eapply star_right; eauto.
+Qed.
+
+Lemma plus_left':
+ forall ge s1 t1 s2 t2 s3 t,
+ step ge s1 t1 s2 -> plus ge s2 t2 s3 -> t = t1 ** t2 ->
+ plus ge s1 t s3.
+Proof.
+ intros. eapply plus_left; eauto. apply plus_star; auto.
+Qed.
+
+Lemma plus_right':
+ forall ge s1 t1 s2 t2 s3 t,
+ plus ge s1 t1 s2 -> step ge s2 t2 s3 -> t = t1 ** t2 ->
+ plus ge s1 t s3.
+Proof.
+ intros. eapply plus_right; eauto. apply plus_star; auto.
+Qed.
+
+Lemma plus_star_trans:
+ forall ge s1 t1 s2 t2 s3 t,
+ plus ge s1 t1 s2 -> star ge s2 t2 s3 -> t = t1 ** t2 -> plus ge s1 t s3.
+Proof.
+ intros. inversion H; subst.
+ econstructor; eauto. eapply star_trans; eauto.
+ traceEq.
+Qed.
+
+Lemma star_plus_trans:
+ forall ge s1 t1 s2 t2 s3 t,
+ star ge s1 t1 s2 -> plus ge s2 t2 s3 -> t = t1 ** t2 -> plus ge s1 t s3.
+Proof.
+ intros. inversion H; subst.
+ simpl; auto.
+ rewrite Eapp_assoc.
+ econstructor. eauto. eapply star_trans. eauto.
+ apply plus_star. eauto. eauto. auto.
+Qed.
+
+Lemma plus_trans:
+ forall ge s1 t1 s2 t2 s3 t,
+ plus ge s1 t1 s2 -> plus ge s2 t2 s3 -> t = t1 ** t2 -> plus ge s1 t s3.
+Proof.
+ intros. eapply plus_star_trans. eauto. apply plus_star. eauto. auto.
+Qed.
+
+Lemma plus_inv:
+ forall ge s1 t s2, plus ge s1 t s2 ->
+ step ge s1 t s2 \/ exists s', exists t1, exists t2, step ge s1 t1 s' /\ plus ge s' t2 s2 /\ t = t1 ** t2.
+Proof.
+ intros. inversion H; subst. inversion H1; subst.
+ left. rewrite E0_right. auto.
+ right. exists s3; exists t1; exists (t0 ** t3); split. auto.
+ split. econstructor; eauto. auto.
+Qed.
+
+(** Infinitely many transitions *)
+
+CoInductive forever (ge: genv): state -> traceinf -> Prop :=
+ | forever_intro: forall s1 t s2 T,
+ step ge s1 t s2 -> forever ge s2 T ->
+ forever ge s1 (t *** T).
+
+(** An alternate, equivalent definition of [forever] that is useful
+ for coinductive reasoning. *)
+
+CoInductive forever_N (ge: genv): nat -> state -> traceinf -> Prop :=
+ | forever_N_star: forall s1 t s2 p q T,
+ star ge s1 t s2 -> (p < q)%nat -> forever_N ge p s2 T ->
+ forever_N ge q s1 (t *** T)
+ | forever_N_plus: forall s1 t s2 p q T,
+ plus ge s1 t s2 -> forever_N ge p s2 T ->
+ forever_N ge q s1 (t *** T).
+
+Remark Peano_induction:
+ forall (P: nat -> Prop),
+ (forall p, (forall q, (q < p)%nat -> P q) -> P p) ->
+ forall p, P p.
+Proof.
+ intros P IH.
+ assert (forall p, forall q, (q < p)%nat -> P q).
+ induction p; intros. elimtype False; omega.
+ apply IH. intros. apply IHp. omega.
+ intro. apply H with (S p). omega.
+Qed.
+
+Lemma forever_N_inv:
+ forall ge p s T,
+ forever_N ge p s T ->
+ exists t, exists s', exists q, exists T',
+ step ge s t s' /\ forever_N ge q s' T' /\ T = t *** T'.
+Proof.
+ intros ge p. pattern p. apply Peano_induction; intros.
+ inv H0.
+ (* star case *)
+ inv H1.
+ (* no transition *)
+ change (E0 *** T0) with T0. apply H with p1. auto. auto.
+ (* at least one transition *)
+ exists t1; exists s0; exists p0; exists (t2 *** T0).
+ split. auto. split. eapply forever_N_star; eauto.
+ apply Eappinf_assoc.
+ (* plus case *)
+ inv H1.
+ exists t1; exists s0; exists (S p1); exists (t2 *** T0).
+ split. auto. split. eapply forever_N_star; eauto.
+ apply Eappinf_assoc.
+Qed.
+
+Lemma forever_N_forever:
+ forall ge p s T, forever_N ge p s T -> forever ge s T.
+Proof.
+ cofix COINDHYP; intros.
+ destruct (forever_N_inv H) as [t [s' [q [T' [A [B C]]]]]].
+ rewrite C. apply forever_intro with s'. auto.
+ apply COINDHYP with q; auto.
+Qed.
+
+(** * Outcomes for program executions *)
+
+(** The two valid outcomes for the execution of a program:
+- Termination, with a finite trace of observable events
+ and an integer value that stands for the process exit code
+ (the return value of the main function).
+- Divergence with an infinite trace of observable events.
+ (The actual events generated by the execution can be a
+ finite prefix of this trace, or the whole trace.)
+*)
+
+Inductive program_behavior: Set :=
+ | Terminates: trace -> int -> program_behavior
+ | Diverges: traceinf -> program_behavior.
+
+(** Given a characterization of initial states and final states,
+ [program_behaves] relates a program behaviour with the
+ sequences of transitions that can be taken from an initial state
+ to a final state. *)
+
+Variable initial_state: state -> Prop.
+Variable final_state: state -> int -> Prop.
+
+Inductive program_behaves (ge: genv): program_behavior -> Prop :=
+ | program_terminates: forall s t s' r,
+ initial_state s ->
+ star ge s t s' ->
+ final_state s' r ->
+ program_behaves ge (Terminates t r)
+ | program_diverges: forall s T,
+ initial_state s ->
+ forever ge s T ->
+ program_behaves ge (Diverges T).
+
+End CLOSURES.
+
+(** * Simulations between two small-step semantics. *)
+
+(** In this section, we show that if two transition relations
+ satisfy certain simulation diagrams, then every program behaviour
+ generated by the first transition relation can also occur
+ with the second transition relation. *)
+
+Section SIMULATION.
+
+(** The first small-step semantics is axiomatized as follows. *)
+
+Variable genv1: Set.
+Variable state1: Set.
+Variable step1: genv1 -> state1 -> trace -> state1 -> Prop.
+Variable initial_state1: state1 -> Prop.
+Variable final_state1: state1 -> int -> Prop.
+Variable ge1: genv1.
+
+(** The second small-step semantics is also axiomatized. *)
+
+Variable genv2: Set.
+Variable state2: Set.
+Variable step2: genv2 -> state2 -> trace -> state2 -> Prop.
+Variable initial_state2: state2 -> Prop.
+Variable final_state2: state2 -> int -> Prop.
+Variable ge2: genv2.
+
+(** We assume given a matching relation between states of both semantics.
+ This matching relation must be compatible with initial states
+ and with final states. *)
+
+
+Variable match_states: state1 -> state2 -> Prop.
+
+Hypothesis match_initial_states:
+ forall st1, initial_state1 st1 ->
+ exists st2, initial_state2 st2 /\ match_states st1 st2.
+
+Hypothesis match_final_states:
+ forall st1 st2 r,
+ match_states st1 st2 ->
+ final_state1 st1 r ->
+ final_state2 st2 r.
+
+(** Simulation when one transition in the first program
+ corresponds to zero, one or several transitions in the second program.
+ However, there is no stuttering: infinitely many transitions
+ in the source program must correspond to infinitely many
+ transitions in the second program. *)
+
+Section SIMULATION_STAR.
+
+(** [measure] is a nonnegative integer associated with states
+ of the first semantics. It must decrease when we take
+ a stuttering step. *)
+
+Variable measure: state1 -> nat.
+
+Hypothesis simulation:
+ forall st1 t st1', step1 ge1 st1 t st1' ->
+ forall st2, match_states st1 st2 ->
+ (exists st2', plus step2 ge2 st2 t st2' /\ match_states st1' st2')
+ \/ (measure st1' < measure st1 /\ t = E0 /\ match_states st1' st2)%nat.
+
+Lemma simulation_star_star:
+ forall st1 t st1', star step1 ge1 st1 t st1' ->
+ forall st2, match_states st1 st2 ->
+ exists st2', star step2 ge2 st2 t st2' /\ match_states st1' st2'.
+Proof.
+ induction 1; intros.
+ exists st2; split. apply star_refl. auto.
+ elim (simulation H H2).
+ intros [st2' [A B]].
+ destruct (IHstar _ B) as [st3' [C D]].
+ exists st3'; split. apply star_trans with t1 st2' t2.
+ apply plus_star; auto. auto. auto. auto.
+ intros [A [B C]]. rewrite H1. rewrite B. simpl. apply IHstar; auto.
+Qed.
+
+Lemma simulation_star_forever:
+ forall st1 st2 T,
+ forever step1 ge1 st1 T -> match_states st1 st2 ->
+ forever step2 ge2 st2 T.
+Proof.
+ assert (forall st1 st2 T,
+ forever step1 ge1 st1 T -> match_states st1 st2 ->
+ forever_N step2 ge2 (measure st1) st2 T).
+ cofix COINDHYP; intros.
+ inversion H; subst. elim (simulation H1 H0).
+ intros [st2' [A B]]. apply forever_N_plus with st2' (measure s2).
+ auto. apply COINDHYP. assumption. assumption.
+ intros [A [B C]].
+ apply forever_N_star with st2 (measure s2).
+ rewrite B. apply star_refl. auto.
+ apply COINDHYP. assumption. auto.
+ intros. eapply forever_N_forever; eauto.
+Qed.
+
+Lemma simulation_star_preservation:
+ forall beh,
+ program_behaves step1 initial_state1 final_state1 ge1 beh ->
+ program_behaves step2 initial_state2 final_state2 ge2 beh.
+Proof.
+ intros. inversion H; subst.
+ destruct (match_initial_states H0) as [s2 [A B]].
+ destruct (simulation_star_star H1 B) as [s2' [C D]].
+ econstructor; eauto.
+ destruct (match_initial_states H0) as [s2 [A B]].
+ econstructor; eauto.
+ eapply simulation_star_forever; eauto.
+Qed.
+
+End SIMULATION_STAR.
+
+(** Lock-step simulation: each transition in the first semantics
+ corresponds to exactly one transition in the second semantics. *)
+
+Section SIMULATION_STEP.
+
+Hypothesis simulation:
+ forall st1 t st1', step1 ge1 st1 t st1' ->
+ forall st2, match_states st1 st2 ->
+ exists st2', step2 ge2 st2 t st2' /\ match_states st1' st2'.
+
+Lemma simulation_step_preservation:
+ forall beh,
+ program_behaves step1 initial_state1 final_state1 ge1 beh ->
+ program_behaves step2 initial_state2 final_state2 ge2 beh.
+Proof.
+ intros.
+ pose (measure := fun (st: state1) => 0%nat).
+ assert (simulation':
+ forall st1 t st1', step1 ge1 st1 t st1' ->
+ forall st2, match_states st1 st2 ->
+ (exists st2', plus step2 ge2 st2 t st2' /\ match_states st1' st2')
+ \/ (measure st1' < measure st1 /\ t = E0 /\ match_states st1' st2)%nat).
+ intros. destruct (simulation H0 H1) as [st2' [A B]].
+ left; exists st2'; split. apply plus_one; auto. auto.
+ eapply simulation_star_preservation; eauto.
+Qed.
+
+End SIMULATION_STEP.
+
+(** Simulation when one transition in the first program corresponds
+ to one or several transitions in the second program. *)
+
+Section SIMULATION_PLUS.
+
+Hypothesis simulation:
+ forall st1 t st1', step1 ge1 st1 t st1' ->
+ forall st2, match_states st1 st2 ->
+ exists st2', plus step2 ge2 st2 t st2' /\ match_states st1' st2'.
+
+Lemma simulation_plus_preservation:
+ forall beh,
+ program_behaves step1 initial_state1 final_state1 ge1 beh ->
+ program_behaves step2 initial_state2 final_state2 ge2 beh.
+Proof.
+ intros.
+ pose (measure := fun (st: state1) => 0%nat).
+ assert (simulation':
+ forall st1 t st1', step1 ge1 st1 t st1' ->
+ forall st2, match_states st1 st2 ->
+ (exists st2', plus step2 ge2 st2 t st2' /\ match_states st1' st2')
+ \/ (measure st1' < measure st1 /\ t = E0 /\ match_states st1' st2)%nat).
+ intros. destruct (simulation H0 H1) as [st2' [A B]].
+ left; exists st2'; auto.
+ eapply simulation_star_preservation; eauto.
+Qed.
+
+End SIMULATION_PLUS.
+
+(** Simulation when one transition in the first program
+ corresponds to zero or one transitions in the second program.
+ However, there is no stuttering: infinitely many transitions
+ in the source program must correspond to infinitely many
+ transitions in the second program. *)
+
+Section SIMULATION_OPT.
+
+Variable measure: state1 -> nat.
+
+Hypothesis simulation:
+ forall st1 t st1', step1 ge1 st1 t st1' ->
+ forall st2, match_states st1 st2 ->
+ (exists st2', step2 ge2 st2 t st2' /\ match_states st1' st2')
+ \/ (measure st1' < measure st1 /\ t = E0 /\ match_states st1' st2)%nat.
+
+Lemma simulation_opt_preservation:
+ forall beh,
+ program_behaves step1 initial_state1 final_state1 ge1 beh ->
+ program_behaves step2 initial_state2 final_state2 ge2 beh.
+Proof.
+ assert (simulation':
+ forall st1 t st1', step1 ge1 st1 t st1' ->
+ forall st2, match_states st1 st2 ->
+ (exists st2', plus step2 ge2 st2 t st2' /\ match_states st1' st2')
+ \/ (measure st1' < measure st1 /\ t = E0 /\ match_states st1' st2)%nat).
+ intros. elim (simulation H H0).
+ intros [st2' [A B]]. left. exists st2'; split. apply plus_one; auto. auto.
+ intros [A [B C]]. right. intuition.
+ intros. eapply simulation_star_preservation; eauto.
+Qed.
+
+End SIMULATION_OPT.
+
+End SIMULATION.
+
+
diff --git a/common/Switch.v b/common/Switch.v
new file mode 100644
index 0000000000000000000000000000000000000000..e8b396719665cf43ff2ff571df35233acea2cbc4
--- /dev/null
+++ b/common/Switch.v
@@ -0,0 +1,165 @@
+(** Multi-way branches (``[switch]'') and their compilation
+ to 2-way comparison trees. *)
+
+Require Import EqNat.
+Require Import Coqlib.
+Require Import Integers.
+
+(** A multi-way branch is composed of a list of (key, action) pairs,
+ plus a default action. *)
+
+Definition table : Set := list (int * nat).
+
+Fixpoint switch_target (n: int) (dfl: nat) (cases: table)
+ {struct cases} : nat :=
+ match cases with
+ | nil => dfl
+ | (key, action) :: rem =>
+ if Int.eq n key then action else switch_target n dfl rem
+ end.
+
+(** Multi-way branches are translated to a 2-way comparison tree.
+ Each node of the tree performs an equality test or a less-than
+ test against one of the keys. *)
+
+Inductive comptree : Set :=
+ | CTaction: nat -> comptree
+ | CTifeq: int -> nat -> comptree -> comptree
+ | CTiflt: int -> comptree -> comptree -> comptree.
+
+Fixpoint comptree_match (n: int) (t: comptree) {struct t}: nat :=
+ match t with
+ | CTaction act => act
+ | CTifeq key act t' =>
+ if Int.eq n key then act else comptree_match n t'
+ | CTiflt key t1 t2 =>
+ if Int.ltu n key then comptree_match n t1 else comptree_match n t2
+ end.
+
+(** The translation from a table to a comparison tree is performed
+ by untrusted Caml code (function [compile_switch] in
+ file [RTLgenaux.ml]). In Coq, we validate a posteriori the
+ result of this function. In other terms, we now develop
+ and prove correct Coq functions that take a table and a comparison
+ tree, and check that their semantics are equivalent. *)
+
+Fixpoint split_lt (pivot: int) (cases: table)
+ {struct cases} : table * table :=
+ match cases with
+ | nil => (nil, nil)
+ | (key, act) :: rem =>
+ let (l, r) := split_lt pivot rem in
+ if Int.ltu key pivot
+ then ((key, act) :: l, r)
+ else (l, (key, act) :: r)
+ end.
+
+Fixpoint split_eq (pivot: int) (cases: table)
+ {struct cases} : option nat * table :=
+ match cases with
+ | nil => (None, nil)
+ | (key, act) :: rem =>
+ let (same, others) := split_eq pivot rem in
+ if Int.eq key pivot
+ then (Some act, others)
+ else (same, (key, act) :: others)
+ end.
+
+Fixpoint validate_switch (default: nat) (cases: table) (t: comptree)
+ {struct t} : bool :=
+ match t with
+ | CTaction act =>
+ match cases with
+ | nil => beq_nat act default
+ | _ => false
+ end
+ | CTifeq pivot act t' =>
+ match split_eq pivot cases with
+ | (None, _) => false
+ | (Some act', others) => beq_nat act act' && validate_switch default others t'
+ end
+ | CTiflt pivot t1 t2 =>
+ match split_lt pivot cases with
+ | (lcases, rcases) =>
+ validate_switch default lcases t1 && validate_switch default rcases t2
+ end
+ end.
+
+(** Correctness proof for validation. *)
+
+Lemma split_eq_prop:
+ forall v default n cases optact cases',
+ split_eq n cases = (optact, cases') ->
+ switch_target v default cases =
+ (if Int.eq v n
+ then match optact with Some act => act | None => default end
+ else switch_target v default cases').
+Proof.
+ induction cases; simpl; intros until cases'.
+ intros. inversion H; subst. simpl.
+ destruct (Int.eq v n); auto.
+ destruct a as [key act].
+ case_eq (split_eq n cases). intros same other SEQ.
+ rewrite (IHcases _ _ SEQ).
+ predSpec Int.eq Int.eq_spec key n; intro EQ; inversion EQ; simpl.
+ subst n. destruct (Int.eq v key). auto. auto.
+ predSpec Int.eq Int.eq_spec v key.
+ subst v. predSpec Int.eq Int.eq_spec key n. congruence. auto.
+ auto.
+Qed.
+
+Lemma split_lt_prop:
+ forall v default n cases lcases rcases,
+ split_lt n cases = (lcases, rcases) ->
+ switch_target v default cases =
+ (if Int.ltu v n
+ then switch_target v default lcases
+ else switch_target v default rcases).
+Proof.
+ induction cases; intros until rcases; simpl.
+ intro. inversion H; subst. simpl.
+ destruct (Int.ltu v n); auto.
+ destruct a as [key act].
+ case_eq (split_lt n cases). intros lc rc SEQ.
+ rewrite (IHcases _ _ SEQ).
+ case_eq (Int.ltu key n); intros; inv H0; simpl.
+ predSpec Int.eq Int.eq_spec v key.
+ subst v. rewrite H. auto.
+ auto.
+ predSpec Int.eq Int.eq_spec v key.
+ subst v. rewrite H. auto.
+ auto.
+Qed.
+
+Definition table_tree_agree
+ (default: nat) (cases: table) (t: comptree) : Prop :=
+ forall v, switch_target v default cases = comptree_match v t.
+
+Lemma validate_switch_correct:
+ forall default t cases,
+ validate_switch default cases t = true ->
+ table_tree_agree default cases t.
+Proof.
+ induction t; simpl; intros until cases.
+ (* base case *)
+ destruct cases. 2: congruence.
+ intro. replace n with default.
+ red; intros; simpl; auto.
+ symmetry. apply beq_nat_eq. auto.
+ (* eq node *)
+ case_eq (split_eq i cases). intros optact cases' EQ.
+ destruct optact as [ act | ]. 2: congruence.
+ intros. destruct (andb_prop _ _ H).
+ replace n with act.
+ generalize (IHt _ H1); intro.
+ red; intros. simpl. rewrite <- H2.
+ change act with (match Some act with Some act => act | None => default end).
+ eapply split_eq_prop; eauto.
+ symmetry. apply beq_nat_eq. auto.
+ (* lt node *)
+ case_eq (split_lt i cases). intros lcases rcases EQ V.
+ destruct (andb_prop _ _ V).
+ red; intros. simpl.
+ rewrite <- (IHt1 _ H). rewrite <- (IHt2 _ H0).
+ eapply split_lt_prop; eauto.
+Qed.
diff --git a/common/Values.v b/common/Values.v
index aa59e045899e1ff87d75574be35055ebbf1d5b1c..e5b497114b728438806067c54cedd30ac82fa061 100644
--- a/common/Values.v
+++ b/common/Values.v
@@ -885,4 +885,68 @@ Proof.
elim H0; intro; subst v; reflexivity.
Qed.
+(** The ``is less defined'' relation between values.
+ A value is less defined than itself, and [Vundef] is
+ less defined than any value. *)
+
+Inductive lessdef: val -> val -> Prop :=
+ | lessdef_refl: forall v, lessdef v v
+ | lessdef_undef: forall v, lessdef Vundef v.
+
+Inductive lessdef_list: list val -> list val -> Prop :=
+ | lessdef_list_nil:
+ lessdef_list nil nil
+ | lessdef_list_cons:
+ forall v1 v2 vl1 vl2,
+ lessdef v1 v2 -> lessdef_list vl1 vl2 ->
+ lessdef_list (v1 :: vl1) (v2 :: vl2).
+
+Hint Resolve lessdef_refl lessdef_undef lessdef_list_nil lessdef_list_cons.
+
+Lemma lessdef_list_inv:
+ forall vl1 vl2, lessdef_list vl1 vl2 -> vl1 = vl2 \/ In Vundef vl1.
+Proof.
+ induction 1; simpl.
+ tauto.
+ inv H. destruct IHlessdef_list.
+ left; congruence. tauto. tauto.
+Qed.
+
+Lemma load_result_lessdef:
+ forall chunk v1 v2,
+ lessdef v1 v2 -> lessdef (load_result chunk v1) (load_result chunk v2).
+Proof.
+ intros. inv H. auto. destruct chunk; simpl; auto.
+Qed.
+
+Lemma cast8signed_lessdef:
+ forall v1 v2, lessdef v1 v2 -> lessdef (cast8signed v1) (cast8signed v2).
+Proof.
+ intros; inv H; simpl; auto.
+Qed.
+
+Lemma cast8unsigned_lessdef:
+ forall v1 v2, lessdef v1 v2 -> lessdef (cast8unsigned v1) (cast8unsigned v2).
+Proof.
+ intros; inv H; simpl; auto.
+Qed.
+
+Lemma cast16signed_lessdef:
+ forall v1 v2, lessdef v1 v2 -> lessdef (cast16signed v1) (cast16signed v2).
+Proof.
+ intros; inv H; simpl; auto.
+Qed.
+
+Lemma cast16unsigned_lessdef:
+ forall v1 v2, lessdef v1 v2 -> lessdef (cast16unsigned v1) (cast16unsigned v2).
+Proof.
+ intros; inv H; simpl; auto.
+Qed.
+
+Lemma singleoffloat_lessdef:
+ forall v1 v2, lessdef v1 v2 -> lessdef (singleoffloat v1) (singleoffloat v2).
+Proof.
+ intros; inv H; simpl; auto.
+Qed.
+
End Val.
diff --git a/coq b/coq
index 1f6bf5f837732b02a3142d1d6ac19d58d6b77d8f..b110c54fcf7a846fb3cfa8c114e467ce2c86b15b 100755
--- a/coq
+++ b/coq
@@ -1,4 +1,4 @@
#!/bin/sh
# Start coqide with the right -I options
-exec coqide -I lib -I common -I backend -I cfrontend "$@"
+coqide -I lib -I common -I backend -I cfrontend $1 && make ${1}o
diff --git a/doc/backend.html b/doc/backend.html
deleted file mode 100644
index e33896ce5777fc18520d2a9320014f7f09e98c72..0000000000000000000000000000000000000000
--- a/doc/backend.html
+++ /dev/null
@@ -1,250 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<HTML>
-<HEAD>
-<TITLE>The Compcert certified compiler back-end</TITLE>
-<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
-
-<style type="text/css">
-body {
- color: black; background: white;
- margin-left: 5%; margin-right: 5%;
-}
-h2 { margin-left: -5%;}
-h3,h4,h5,h6 { margin-left: -3%; }
-hr { margin-left: -5%; margin-right:-5%; }
-a:visited {color : #416DFF; text-decoration : none; }
-a:link {color : #416DFF; text-decoration : none; font-weight : bold}
-a:hover {color : Red; text-decoration : underline; }
-a:active {color : Red; text-decoration : underline; }
-</style>
-
-<LINK type="text/css" rel="stylesheet" href="style.css">
-</HEAD>
-<BODY>
-
-<H1 align="center">The Compcert certified compiler back-end</H1>
-<H2 align="center">Commented Coq development</H2>
-<H3 align="center">Version 0.2, 2006-01-07</H3>
-
-<H2>Introduction</H2>
-
-<P>The Compcert back-end is a compiler that generates PowerPC assembly
-code from a low-level intermediate language called Cminor and a
-slightly more expressive intermediate language called Csharpminor.
-The particularity of this compiler is that it is written mostly within
-the specification language of the Coq proof assistant, and its
-correctness --- the fact that the generated assembly code is
-semantically equivalent to its source program --- was entirely proved
-within the Coq proof assistant.</P>
-
-<P>A high-level overview of the Compcert back-end and its proof of
-correctness can be found in the following paper:</P>
-<CITE>Xavier Leroy, <A
-HREF="http://pauillac.inria.fr/~xleroy/publi/compiler-certif.pdf">Formal
-certification of a compiler back-end, or: programming a compiler with
-a proof assistant</A>. Proceedings of the POPL 2006 symposium.</CITE>
-
-<P>This Web site gives a commented listing of the underlying Coq
-specifications and proofs. Proof scripts and the parts of the
-compiler written directly in Caml are omitted. This development is a
-work in progress; some parts may have changed since the overview paper
-above was written.</P>
-
-<P>This document and all Coq source files referenced from it are
-copyright 2005, 2006 Institut National de Recherche en Informatique et
-en Automatique (INRIA) and distributed under the terms of the <A
-HREF="http://www.gnu.org/licenses/gpl.html">GNU General Public
-License</A> version 2.</P>
-
-<H2>Table of contents</H2>
-
-<H3>Libraries, algorithms, data structures</H3>
-
-<UL>
-<LI> <A HREF="lib.Coqlib.html">Coqlib</A>: addendum to the Coq standard library.
- (Coq source file with proofs:
- <A HREF="Coqlib.v"><code>Coqlib.v</code></a>.)
-<LI> <A HREF="lib.Maps.html">Maps</A>: finite maps.
- (Coq source file with proofs:
- <A HREF="Maps.v"><code>Maps.v</code></a>.)
-<LI> <A HREF="lib.Sets.html">Sets</A>: finite sets.
-<LI> <A HREF="lib.union_find.html">Union-find</A>: representation of
-equivalence classes.
- (Coq source file with proofs:
- <A HREF="union_find.v"><code>union_find.v</code></a>.)
-<LI> <A HREF="lib.Inclusion.html">Inclusion</A>: tactics to prove list inclusions.
-<LI> <A HREF="backend.AST.html">AST</A>: identifiers, whole programs and other
-common elements of abstract syntaxes.
- (Coq source file with proofs:
- <A HREF="AST.v"><code>AST.v</code></a>.)
-<LI> <A HREF="lib.Integers.html">Integers</A>: machine integers.
- (Coq source file with proofs:
- <A HREF="Integers.v"><code>Integers.v</code></a>.)
-<LI> <A HREF="lib.Floats.html">Floats</A>: machine floating-point numbers.
-<LI> <A HREF="backend.Mem.html">Mem</A>: the memory model.
-<LI> <A HREF="backend.Globalenvs.html">Globalenvs</A>: global execution environments.
-<LI> <A HREF="backend.Op.html">Op</A>: operators, addressing modes and their
-semantics.
-<LI> <A HREF="lib.Ordered.html">Ordered</A>: construction of
-ordered types.
-<LI> <A HREF="lib.Lattice.html">Lattice</A>: construction of
-semi-lattices.
-<LI> <A HREF="backend.Kildall.html">Kildall</A>: resolution of dataflow
-inequations by fixpoint iteration.
-</UL>
-
-<H3>Source, intermediate and target languages: syntax and semantics</H3>
-
-<UL>
-<LI> <A HREF="backend.Csharpminor.html">Csharpminor</A>: low-level structured language.
-<LI> <A HREF="backend.Cminor.html">Cminor</A>: low-level structured
-language, with explicit stack allocation of certain local variables.
-<LI> <A HREF="backend.RTL.html">RTL</A>: register transfer language (3-address
-code, control-flow graph, infinitely many pseudo-registers). <BR>
-See also: <A HREF="backend.Registers.html">Registers</A> (representation of
-pseudo-registers).
-<LI> <A HREF="backend.LTL.html">LTL</A>: location transfer language (3-address
-code, control-flow graph, finitely many physical registers, infinitely
-many stack slots). <BR>
-See also: <A HREF="backend.Locations.html">Locations</A> (representation of
-locations).
-<LI> <A HREF="backend.Linear.html">Linear</A>: like LTL, but the CFG is
-replaced by a linear list of instructions with explicit branches and labels.
-<LI> <A HREF="backend.Mach.html">Mach</A>: like Linear, with a more concrete
-view of the activation record. <BR>
-See also: an alternate semantics for the same
-syntax is given in <A HREF="backend.Machabstr.html">Machabstr</A>. <BR>
-<LI> <A HREF="backend.PPC.html">PPC</A>: abstract syntax for PowerPC assembly
-code.
-</UL>
-
-<H3>Compiler passes</H3>
-
-<TABLE cellpadding="5%">
-<TR valign="top">
- <TH>Pass</TH>
- <TH>Source & target</TH>
- <TH>Compiler code</TH>
- <TH>Correctness proof</TH>
-</TR>
-
-<TR valign="top">
- <TD>Recognition of operators and addressing modes</TD>
- <TD>Csharpminor to Cminor</TD>
- <TD><A HREF="backend.Cmconstr.html">Cmconstr</A></TD>
- <TD><A HREF="backend.Cmconstrproof.html">Cmconstrproof</A></TD>
-</TR>
-
-<TR valign="top">
- <TD>Stack allocation of local variables<br>whose address is taken</TD>
- <TD>Csharpminor to Cminor</TD>
- <TD><A HREF="backend.Cminorgen.html">Cminorgen</A></TD>
- <TD><A HREF="backend.Cminorgenproof.html">Cminorgenproof</A></TD>
-</TR>
-
-<TR valign="top">
- <TD>Construction of the CFG, <br>3-address code generation</TD>
- <TD>Cminor to RTL</TD>
- <TD><A HREF="backend.RTLgen.html">RTLgen</A></TD>
- <TD><A HREF="backend.RTLgenproof1.html">RTLgenproof1</A><BR>
- <A HREF="backend.RTLgenproof.html">RTLgenproof</A></TD>
-</TR>
-
-<TR valign="top">
- <TD>Constant propagation</TD>
- <TD>RTL to RTL</TD>
- <TD><A HREF="backend.Constprop.html">Constprop</A></TD>
- <TD><A HREF="backend.Constpropproof.html">Constpropproof</A></TD>
-</TR>
-
-<TR valign="top">
- <TD>Common subexpression elimination</TD>
- <TD>RTL to RTL</TD>
- <TD><A HREF="backend.CSE.html">CSE</A></TD>
- <TD><A HREF="backend.CSEproof.html">CSEproof</A></TD>
-</TR>
-
-<TR valign="top">
- <TD>Register allocation by coloring<br>of an interference graph</TD>
- <TD>RTL to LTL</TD>
- <TD><A HREF="backend.Conventions.html">Conventions</A><BR>
- <A HREF="backend.InterfGraph.html">InterfGraph</A><BR>
- <A HREF="backend.Coloring.html">Coloring</A><BR>
- <A HREF="backend.Parallelmove.html">Parallelmove</A><BR>
- <A HREF="backend.Allocation.html">Allocation</A></TD>
- <TD><BR>
- <BR>
- <A HREF="backend.Coloringproof.html">Coloringproof</A><BR>
- <A HREF="backend.Allocproof_aux.html">Allocproof_aux</A><BR>
- <A HREF="backend.Allocproof.html">Allocproof</A></TD>
-</TR>
-
-<TR valign="top">
- <TD>Branch tunneling</TD>
- <TD>LTL to LTL</TD>
- <TD><A HREF="backend.Tunneling.html">Tunneling</A></TD>
- <TD><A HREF="backend.Tunnelingproof.html">Tunnelingproof</A></TD>
-</TR>
-
-<TR valign="top">
- <TD>Linearization of the CFG</TD>
- <TD>LTL to Linear</TD>
- <TD><A HREF="backend.Linearize.html">Linearize</A></TD>
- <TD><A HREF="backend.Linearizeproof.html">Linearizeproof</A></TD>
-</TR>
-
-<TR valign="top">
- <TD>Laying out the activation records</TD>
- <TD>Linear to Mach</TD>
- <TD><A HREF="backend.Stacking.html">Stacking</A></TD>
- <TD><A HREF="backend.Stackingroof.html">Stackingproof</A></TD>
-</TR>
-
-<TR valign="top">
- <TD>Storing the activation records in memory</TD>
- <TD>Mach to Mach</TD>
- <TD>(none)
- <TD><A HREF="backend.Machabstr2mach.html">Machabstr2mach</A></TD>
-
-<TR valign="top">
- <TD>Emission of PowerPC assembly</TD>
- <TD>Mach to PPC</TD>
- <TD><A HREF="backend.PPCgen.html">PPCgen</A></TD>
- <TD><A HREF="backend.PPCgenproof1.html">PPCgenproof1</A><BR>
- <A HREF="backend.PPCgenproof.html">PPCgenproof</A></TD>
-</TR>
-</TABLE>
-
-<H3>Type systems</H3>
-
-Trivial type systems are used to statically capture well-formedness
-conditions on the intermediate languages.
-<UL>
-<LI> <A HREF="backend.RTLtyping.html">RTLtyping</A>: typing for RTL + type
-reconstruction.
-<LI> <A HREF="backend.LTLtyping.html">LTLtyping</A>: typing for LTL.
-<LI> <A HREF="backend.Lineartyping.html">Lineartyping</A>: typing for Linear.
-<LI> <A HREF="backend.Machtyping.html">Machtyping</A>: typing for Mach.
-</UL>
-Proofs that compiler passes are type-preserving:
-<UL>
-<LI> <A HREF="backend.Alloctyping_aux.html">Alloctyping_aux</A> and
- <A HREF="backend.Alloctyping.html">Alloctyping</A> (register allocation).
-<LI> <A HREF="backend.Tunnelingtyping.html">Tunnelingtyping</A> (branch tunneling).
-<LI> <A HREF="backend.Lineartyping.html">Lineartyping</A> (branch tunneling).
-<LI> <A HREF="backend.Stackingtyping.html">Stackingtyping</A> (layout of activation records).
-</UL>
-
-<H3>All together</H3>
-
-<UL>
-<LI> <A HREF="backend.Main.html">Main</A>: composing the passes together; the
-final semantic preservation theorems.
-</UL>
-
-<HR>
-<ADDRESS>Xavier.Leroy@inria.fr</ADDRESS>
-<HR>
-
-</BODY>
-</HTML>
diff --git a/doc/coqdoc.css b/doc/coqdoc.css
new file mode 100644
index 0000000000000000000000000000000000000000..f2ae96da2d26ed083ccc8ba41c12bd3d34eb8b28
--- /dev/null
+++ b/doc/coqdoc.css
@@ -0,0 +1,62 @@
+body {
+ color: black;
+ background: white;
+ margin-left: 15%;
+ margin-right: 5%;
+}
+
+#main a.idref:visited {color : #416DFF; text-decoration : none; }
+#main a.idref:link {color : #416DFF; text-decoration : none; }
+#main a.idref:hover {text-decoration : none; }
+#main a.idref:active {text-decoration : none; }
+
+#main a.modref:visited {color : #416DFF; text-decoration : none; }
+#main a.modref:link {color : #416DFF; text-decoration : none; }
+#main a.modref:hover {text-decoration : none; }
+#main a.modref:active {text-decoration : none; }
+
+#main .keyword { color : #cf1d1d }
+
+#main .doc {
+ margin-left: -5%;
+}
+
+#main span.docright {
+ position: absolute;
+ left: 60%;
+ width: 40%
+}
+
+h1.libtitle {
+ font-size: 2em;
+ margin-left: -15%;
+ margin-right: -5%;
+ text-align: center
+}
+
+h1 {
+ font-size: 1.5em;
+}
+h2 {
+ font-size: 1.17em;
+}
+
+h1, h2 {
+ font-family: sans-serif;
+}
+
+.doc code {
+ color: #008000;
+}
+
+/* Pied de page */
+
+hr { margin-left: -15%; margin-right:-5%; }
+
+#footer { font-size: 0.83em;
+ font-family: sans-serif; }
+
+#footer a:visited { color: blue; }
+#footer a:link { text-decoration: none;
+ color: #888888; }
+
diff --git a/doc/index.html b/doc/index.html
index 33afe85ebecc0471826d17e6d298eb1e421b894e..709767b7b90da75f8bd4fdcada0e331ec359955f 100644
--- a/doc/index.html
+++ b/doc/index.html
@@ -1,8295 +1,270 @@
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset="><link rel="stylesheet" href="style.css" type="text/css"><title>Index</title>
-</head>
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<HTML>
+<HEAD>
+<TITLE>The Compcert certified compiler back-end</TITLE>
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
-<body>
+<style type="text/css">
+body {
+ color: black; background: white;
+ margin-left: 5%; margin-right: 5%;
+}
+h2 { margin-left: -5%;}
+h3,h4,h5,h6 { margin-left: -3%; }
+hr { margin-left: -5%; margin-right:-5%; }
+a:visited {color : #416DFF; text-decoration : none; font-weight : bold}
+a:link {color : #416DFF; text-decoration : none; font-weight : bold}
+a:hover {color : Red; text-decoration : underline; }
+a:active {color : Red; text-decoration : underline; }
+</style>
-<table>
-<tr>
-<td>Global Index</td>
-<td><a href="index.html#global_A">A</a></td>
-<td><a href="index.html#global_B">B</a></td>
-<td><a href="index.html#global_C">C</a></td>
-<td><a href="index.html#global_D">D</a></td>
-<td><a href="index.html#global_E">E</a></td>
-<td><a href="index.html#global_F">F</a></td>
-<td><a href="index.html#global_G">G</a></td>
-<td><a href="index.html#global_H">H</a></td>
-<td><a href="index.html#global_I">I</a></td>
-<td>J</td>
-<td><a href="index.html#global_K">K</a></td>
-<td><a href="index.html#global_L">L</a></td>
-<td><a href="index.html#global_M">M</a></td>
-<td><a href="index.html#global_N">N</a></td>
-<td><a href="index.html#global_O">O</a></td>
-<td><a href="index.html#global_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#global_R">R</a></td>
-<td><a href="index.html#global_S">S</a></td>
-<td><a href="index.html#global_T">T</a></td>
-<td><a href="index.html#global_U">U</a></td>
-<td><a href="index.html#global_V">V</a></td>
-<td><a href="index.html#global_W">W</a></td>
-<td><a href="index.html#global_X">X</a></td>
-<td>Y</td>
-<td><a href="index.html#global_Z">Z</a></td>
-<td><a href="index.html#global__">_</a></td>
-<td>(3806 entries)</td>
-</tr>
-<tr>
-<td>Axiom Index</td>
-<td><a href="index.html#axiom_A">A</a></td>
-<td>B</td>
-<td><a href="index.html#axiom_C">C</a></td>
-<td><a href="index.html#axiom_D">D</a></td>
-<td><a href="index.html#axiom_E">E</a></td>
-<td><a href="index.html#axiom_F">F</a></td>
-<td><a href="index.html#axiom_G">G</a></td>
-<td><a href="index.html#axiom_H">H</a></td>
-<td><a href="index.html#axiom_I">I</a></td>
-<td>J</td>
-<td>K</td>
-<td><a href="index.html#axiom_L">L</a></td>
-<td><a href="index.html#axiom_M">M</a></td>
-<td><a href="index.html#axiom_N">N</a></td>
-<td><a href="index.html#axiom_O">O</a></td>
-<td><a href="index.html#axiom_P">P</a></td>
-<td>Q</td>
-<td>R</td>
-<td><a href="index.html#axiom_S">S</a></td>
-<td>T</td>
-<td>U</td>
-<td>V</td>
-<td>W</td>
-<td>X</td>
-<td>Y</td>
-<td><a href="index.html#axiom_Z">Z</a></td>
-<td>_</td>
-<td>(39 entries)</td>
-</tr>
-<tr>
-<td>Lemma Index</td>
-<td><a href="index.html#lemma_A">A</a></td>
-<td><a href="index.html#lemma_B">B</a></td>
-<td><a href="index.html#lemma_C">C</a></td>
-<td><a href="index.html#lemma_D">D</a></td>
-<td><a href="index.html#lemma_E">E</a></td>
-<td><a href="index.html#lemma_F">F</a></td>
-<td><a href="index.html#lemma_G">G</a></td>
-<td><a href="index.html#lemma_H">H</a></td>
-<td><a href="index.html#lemma_I">I</a></td>
-<td>J</td>
-<td><a href="index.html#lemma_K">K</a></td>
-<td><a href="index.html#lemma_L">L</a></td>
-<td><a href="index.html#lemma_M">M</a></td>
-<td><a href="index.html#lemma_N">N</a></td>
-<td><a href="index.html#lemma_O">O</a></td>
-<td><a href="index.html#lemma_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#lemma_R">R</a></td>
-<td><a href="index.html#lemma_S">S</a></td>
-<td><a href="index.html#lemma_T">T</a></td>
-<td><a href="index.html#lemma_U">U</a></td>
-<td><a href="index.html#lemma_V">V</a></td>
-<td><a href="index.html#lemma_W">W</a></td>
-<td><a href="index.html#lemma_X">X</a></td>
-<td>Y</td>
-<td><a href="index.html#lemma_Z">Z</a></td>
-<td>_</td>
-<td>(1753 entries)</td>
-</tr>
-<tr>
-<td>Constructor Index</td>
-<td><a href="index.html#constructor_A">A</a></td>
-<td><a href="index.html#constructor_B">B</a></td>
-<td><a href="index.html#constructor_C">C</a></td>
-<td><a href="index.html#constructor_D">D</a></td>
-<td><a href="index.html#constructor_E">E</a></td>
-<td><a href="index.html#constructor_F">F</a></td>
-<td><a href="index.html#constructor_G">G</a></td>
-<td>H</td>
-<td><a href="index.html#constructor_I">I</a></td>
-<td>J</td>
-<td>K</td>
-<td><a href="index.html#constructor_L">L</a></td>
-<td><a href="index.html#constructor_M">M</a></td>
-<td><a href="index.html#constructor_N">N</a></td>
-<td><a href="index.html#constructor_O">O</a></td>
-<td><a href="index.html#constructor_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#constructor_R">R</a></td>
-<td><a href="index.html#constructor_S">S</a></td>
-<td><a href="index.html#constructor_T">T</a></td>
-<td><a href="index.html#constructor_U">U</a></td>
-<td><a href="index.html#constructor_V">V</a></td>
-<td><a href="index.html#constructor_W">W</a></td>
-<td>X</td>
-<td>Y</td>
-<td>Z</td>
-<td><a href="index.html#constructor__">_</a></td>
-<td>(700 entries)</td>
-</tr>
-<tr>
-<td>Inductive Index</td>
-<td><a href="index.html#inductive_A">A</a></td>
-<td><a href="index.html#inductive_B">B</a></td>
-<td><a href="index.html#inductive_C">C</a></td>
-<td><a href="index.html#inductive_D">D</a></td>
-<td><a href="index.html#inductive_E">E</a></td>
-<td><a href="index.html#inductive_F">F</a></td>
-<td><a href="index.html#inductive_G">G</a></td>
-<td>H</td>
-<td><a href="index.html#inductive_I">I</a></td>
-<td>J</td>
-<td>K</td>
-<td><a href="index.html#inductive_L">L</a></td>
-<td><a href="index.html#inductive_M">M</a></td>
-<td><a href="index.html#inductive_N">N</a></td>
-<td><a href="index.html#inductive_O">O</a></td>
-<td><a href="index.html#inductive_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#inductive_R">R</a></td>
-<td><a href="index.html#inductive_S">S</a></td>
-<td><a href="index.html#inductive_T">T</a></td>
-<td><a href="index.html#inductive_U">U</a></td>
-<td><a href="index.html#inductive_V">V</a></td>
-<td><a href="index.html#inductive_W">W</a></td>
-<td>X</td>
-<td>Y</td>
-<td>Z</td>
-<td>_</td>
-<td>(155 entries)</td>
-</tr>
-<tr>
-<td>Definition Index</td>
-<td><a href="index.html#definition_A">A</a></td>
-<td><a href="index.html#definition_B">B</a></td>
-<td><a href="index.html#definition_C">C</a></td>
-<td><a href="index.html#definition_D">D</a></td>
-<td><a href="index.html#definition_E">E</a></td>
-<td><a href="index.html#definition_F">F</a></td>
-<td><a href="index.html#definition_G">G</a></td>
-<td><a href="index.html#definition_H">H</a></td>
-<td><a href="index.html#definition_I">I</a></td>
-<td>J</td>
-<td><a href="index.html#definition_K">K</a></td>
-<td><a href="index.html#definition_L">L</a></td>
-<td><a href="index.html#definition_M">M</a></td>
-<td><a href="index.html#definition_N">N</a></td>
-<td><a href="index.html#definition_O">O</a></td>
-<td><a href="index.html#definition_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#definition_R">R</a></td>
-<td><a href="index.html#definition_S">S</a></td>
-<td><a href="index.html#definition_T">T</a></td>
-<td><a href="index.html#definition_U">U</a></td>
-<td><a href="index.html#definition_V">V</a></td>
-<td><a href="index.html#definition_W">W</a></td>
-<td><a href="index.html#definition_X">X</a></td>
-<td>Y</td>
-<td><a href="index.html#definition_Z">Z</a></td>
-<td>_</td>
-<td>(1017 entries)</td>
-</tr>
-<tr>
-<td>Module Index</td>
-<td><a href="index.html#module_A">A</a></td>
-<td><a href="index.html#module_B">B</a></td>
-<td>C</td>
-<td><a href="index.html#module_D">D</a></td>
-<td><a href="index.html#module_E">E</a></td>
-<td><a href="index.html#module_F">F</a></td>
-<td><a href="index.html#module_G">G</a></td>
-<td>H</td>
-<td><a href="index.html#module_I">I</a></td>
-<td>J</td>
-<td>K</td>
-<td><a href="index.html#module_L">L</a></td>
-<td><a href="index.html#module_M">M</a></td>
-<td><a href="index.html#module_N">N</a></td>
-<td><a href="index.html#module_O">O</a></td>
-<td><a href="index.html#module_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#module_R">R</a></td>
-<td><a href="index.html#module_S">S</a></td>
-<td><a href="index.html#module_T">T</a></td>
-<td><a href="index.html#module_U">U</a></td>
-<td><a href="index.html#module_V">V</a></td>
-<td>W</td>
-<td>X</td>
-<td>Y</td>
-<td><a href="index.html#module_Z">Z</a></td>
-<td>_</td>
-<td>(78 entries)</td>
-</tr>
-<tr>
-<td>Library Index</td>
-<td><a href="index.html#library_A">A</a></td>
-<td>B</td>
-<td><a href="index.html#library_C">C</a></td>
-<td>D</td>
-<td>E</td>
-<td><a href="index.html#library_F">F</a></td>
-<td><a href="index.html#library_G">G</a></td>
-<td>H</td>
-<td><a href="index.html#library_I">I</a></td>
-<td>J</td>
-<td><a href="index.html#library_K">K</a></td>
-<td><a href="index.html#library_L">L</a></td>
-<td><a href="index.html#library_M">M</a></td>
-<td>N</td>
-<td><a href="index.html#library_O">O</a></td>
-<td><a href="index.html#library_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#library_R">R</a></td>
-<td><a href="index.html#library_S">S</a></td>
-<td><a href="index.html#library_T">T</a></td>
-<td><a href="index.html#library_U">U</a></td>
-<td><a href="index.html#library_V">V</a></td>
-<td>W</td>
-<td>X</td>
-<td>Y</td>
-<td>Z</td>
-<td>_</td>
-<td>(64 entries)</td>
-</tr>
-</table>
-<hr/>
-<h1>Global Index</h1>
-<a name="global_A"></a><h2>A </h2>
-<a href="backend.Op.html#a">a</a> [inductive, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#a">a</a> [inductive, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Abased">Abased</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Floats.html#abs">abs</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Values.html#absf">absf</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#absfloat">absfloat</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Floats.html#add">add</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Values.html#add">add</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Sets.html#add">add</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Cmconstr.html#add">add</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.RTLtyping.html#add">add</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Integers.html#add">add</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#addf">addf</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#addf">addf</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#addf_cases">addf_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addf_case1">addf_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addf_case2">addf_case2</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Floats.html#addf_commut">addf_commut</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Values.html#addf_commut">addf_commut</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#addf_default">addf_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addf_match">addf_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addf_match_aux">addf_match_aux</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.PPCgen.html#addimm">addimm</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Cmconstr.html#addimm">addimm</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_cases">addimm_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_case1">addimm_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_case2">addimm_case2</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_case3">addimm_case3</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_case4">addimm_case4</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.PPCgenproof1.html#addimm_correct">addimm_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_default">addimm_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_match">addimm_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.PPCgen.html#addimm_1">addimm_1</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#addimm_1_correct">addimm_1_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgen.html#addimm_2">addimm_2</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#addimm_2_correct">addimm_2_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Cmconstr.html#addressing">addressing</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Op.html#addressing">addressing</a> [inductive, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_cases">addressing_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case1">addressing_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case2">addressing_case2</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case3">addressing_case3</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case4">addressing_case4</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case5">addressing_case5</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_default">addressing_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_match">addressing_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Mem.html#address_inject">address_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction">addr_strength_reduction</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_cases">addr_strength_reduction_cases</a> [inductive, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_case1">addr_strength_reduction_case1</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_case2">addr_strength_reduction_case2</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_case3">addr_strength_reduction_case3</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#addr_strength_reduction_correct">addr_strength_reduction_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_default">addr_strength_reduction_default</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_match">addr_strength_reduction_match</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cminorgen.html#addr_taken_expr">addr_taken_expr</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#addr_taken_stmt">addr_taken_stmt</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="lib.Integers.html#add_and">add_and</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#add_assoc">add_assoc</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#add_assoc">add_assoc</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Allocation.html#add_call">add_call</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#add_call_correct">add_call_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cmconstr.html#add_cases">add_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_case1">add_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_case2">add_case2</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_case3">add_case3</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_case4">add_case4</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_case5">add_case5</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#add_commut">add_commut</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#add_commut">add_commut</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Allocation.html#add_cond">add_cond</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#add_cond_correct">add_cond_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cmconstr.html#add_default">add_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Coloring.html#add_edges_instr">add_edges_instr</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#add_edges_instrs">add_edges_instrs</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instrs_correct">add_edges_instrs_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instrs_correct_aux">add_edges_instrs_correct_aux</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instrs_incl_aux">add_edges_instrs_incl_aux</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instr_correct">add_edges_instr_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instr_incl">add_edges_instr_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Allocation.html#add_entry">add_entry</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#add_entry_correct">add_entry_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Globalenvs.html#add_funct">add_funct</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#add_functs">add_functs</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#add_functs_transf">add_functs_transf</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#add_globals">add_globals</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.RTLgen.html#add_instr">add_instr</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_instr_at">add_instr_at</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_instr_incr">add_instr_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#add_instr_wf">add_instr_wf</a> [lemma, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf">add_interf</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#add_interf_call">add_interf_call</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_correct">add_interf_call_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_correct_aux_1">add_interf_call_correct_aux_1</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_correct_aux_2">add_interf_call_correct_aux_2</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_incl">add_interf_call_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_incl_aux_1">add_interf_call_incl_aux_1</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_incl_aux_2">add_interf_call_incl_aux_2</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_correct">add_interf_correct</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#add_interf_entry">add_interf_entry</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_entry_correct">add_interf_entry_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_entry_incl">add_interf_entry_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_incl">add_interf_incl</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#add_interf_live">add_interf_live</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_live_correct">add_interf_live_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_live_correct_aux">add_interf_live_correct_aux</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_live_incl">add_interf_live_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_live_incl_aux">add_interf_live_incl_aux</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloring.html#add_interf_move">add_interf_move</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_move_correct">add_interf_move_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_move_incl">add_interf_move_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_mreg">add_interf_mreg</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_mreg_correct">add_interf_mreg_correct</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_mreg_incl">add_interf_mreg_incl</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#add_interf_op">add_interf_op</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_op_correct">add_interf_op_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_op_incl">add_interf_op_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloring.html#add_interf_params">add_interf_params</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_params_correct">add_interf_params_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_params_correct_aux">add_interf_params_correct_aux</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_params_incl">add_interf_params_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_params_incl_aux">add_interf_params_incl_aux</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.RTLgen.html#add_letvar">add_letvar</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_letvar_wf">add_letvar_wf</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.CSE.html#add_load">add_load</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Allocation.html#add_load">add_load</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#add_load_correct">add_load_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.CSEproof.html#add_load_satisfiable">add_load_satisfiable</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Cmconstr.html#add_match">add_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_match_aux">add_match_aux</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.RTLgen.html#add_move">add_move</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Allocation.html#add_move">add_move</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.RTLgenproof.html#add_move_correct">add_move_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Allocproof.html#add_move_correct">add_move_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_move_incr">add_move_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="lib.Integers.html#add_neg_zero">add_neg_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Allocation.html#add_op">add_op</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.CSE.html#add_op">add_op</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Allocproof.html#add_op_correct">add_op_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.CSEproof.html#add_op_satisfiable">add_op_satisfiable</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Values.html#add_permut">add_permut</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#add_permut">add_permut</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#add_permut_4">add_permut_4</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.InterfGraph.html#add_pref">add_pref</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#add_prefs_call">add_prefs_call</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#add_prefs_call_incl">add_prefs_call_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#add_pref_incl">add_pref_incl</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#add_pref_mreg">add_pref_mreg</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#add_pref_mreg_incl">add_pref_mreg_incl</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Allocation.html#add_reload">add_reload</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#add_reloads">add_reloads</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#add_reloads_correct">add_reloads_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#add_reloads_correct_rec">add_reloads_correct_rec</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#add_reload_correct">add_reload_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocation.html#add_return">add_return</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#add_return_correct">add_return_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.CSE.html#add_rhs">add_rhs</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#add_rhs_satisfiable">add_rhs_satisfiable</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.Integers.html#add_signed">add_signed</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Allocation.html#add_spill">add_spill</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#add_spill_correct">add_spill_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocation.html#add_store">add_store</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#add_store_correct">add_store_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Kildall.html#add_successors">add_successors</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#add_successors_correct">add_successors_correct</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Globalenvs.html#add_symbol">add_symbol</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Kildall.html#add_to_worklist">add_to_worklist</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#add_to_worklist_1">add_to_worklist_1</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#add_to_worklist_2">add_to_worklist_2</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Allocation.html#add_undefs">add_undefs</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#add_undefs_correct">add_undefs_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="lib.Integers.html#add_unsigned">add_unsigned</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLgen.html#add_var">add_var</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#add_vars">add_vars</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_vars_incr">add_vars_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_vars_letenv">add_vars_letenv</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_vars_valid">add_vars_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_vars_wf">add_vars_wf</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_find">add_var_find</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_incr">add_var_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_letenv">add_var_letenv</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_valid">add_var_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_wf">add_var_wf</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="lib.Integers.html#add_zero">add_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Op.html#Aglobal">Aglobal</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Stackingproof.html#agree">agree</a> [inductive, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Allocproof.html#agree">agree</a> [definition, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree">agree</a> [definition, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#agree_assign_dead">agree_assign_dead</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_assign_live">agree_assign_live</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_call">agree_call</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Stackingproof.html#agree_eval_reg">agree_eval_reg</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_eval_reg">agree_eval_reg</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Stackingproof.html#agree_eval_regs">agree_eval_regs</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_eval_regs">agree_eval_regs</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_exten">agree_exten</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_exten_1">agree_exten_1</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_exten_2">agree_exten_2</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#agree_increasing">agree_increasing</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_init_regs">agree_init_regs</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_move_live">agree_move_live</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_nextinstr">agree_nextinstr</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_nextinstr_commut">agree_nextinstr_commut</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#agree_parameters">agree_parameters</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_reg_list_live">agree_reg_list_live</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_reg_live">agree_reg_live</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_reg_sum_live">agree_reg_sum_live</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Stackingproof.html#agree_return_regs">agree_return_regs</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_commut">agree_set_commut</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Stackingproof.html#agree_set_local">agree_set_local</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mfreg">agree_set_mfreg</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mireg">agree_set_mireg</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mireg_exten">agree_set_mireg_exten</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mireg_twice">agree_set_mireg_twice</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mreg">agree_set_mreg</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_other">agree_set_other</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Stackingproof.html#agree_set_outgoing">agree_set_outgoing</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#agree_set_reg">agree_set_reg</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_twice_mireg">agree_set_twice_mireg</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Op.html#Aindexed">Aindexed</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Aindexed2">Aindexed2</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ainstack">Ainstack</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Coqlib.html#align">align</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#align_le">align_le</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Mach.html#align_16_top">align_16_top</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mem.html#alloc">alloc</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Allocation.html">Allocation</a> [library]<br/>
-<a href="backend.Allocproof.html">Allocproof</a> [library]<br/>
-<a href="backend.Allocproof_aux.html">Allocproof_aux</a> [library]<br/>
-<a href="backend.Alloctyping.html#allocs_write_ok">allocs_write_ok</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html">Alloctyping</a> [library]<br/>
-<a href="backend.Alloctyping_aux.html">Alloctyping_aux</a> [library]<br/>
-<a href="backend.Mem.html#alloc_extends">alloc_extends</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#alloc_mapped_inject">alloc_mapped_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Coloring.html#alloc_of_coloring">alloc_of_coloring</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#alloc_of_coloring_correct_1">alloc_of_coloring_correct_1</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#alloc_of_coloring_correct_2">alloc_of_coloring_correct_2</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#alloc_of_coloring_correct_3">alloc_of_coloring_correct_3</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#alloc_of_coloring_correct_4">alloc_of_coloring_correct_4</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.RTLgen.html#alloc_reg">alloc_reg</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#alloc_regs">alloc_regs</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_regs_fresh_or_in_map">alloc_regs_fresh_or_in_map</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_regs_incr">alloc_regs_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_regs_target_ok">alloc_regs_target_ok</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_regs_valid">alloc_regs_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_reg_fresh_or_in_map">alloc_reg_fresh_or_in_map</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_reg_incr">alloc_reg_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_reg_target_ok">alloc_reg_target_ok</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_reg_valid">alloc_reg_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Mem.html#alloc_right_inject">alloc_right_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Alloctyping.html#alloc_type">alloc_type</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#alloc_types">alloc_types</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Mem.html#alloc_unmapped_inject">alloc_unmapped_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Csharpminor.html#alloc_variables">alloc_variables</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#alloc_variables_cons">alloc_variables_cons</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminorgenproof.html#alloc_variables_list_block">alloc_variables_list_block</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#alloc_variables_nextblock_incr">alloc_variables_nextblock_incr</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Csharpminor.html#alloc_variables_nil">alloc_variables_nil</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Alloctyping.html#alloc_write_ok">alloc_write_ok</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs">all_interf_regs</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_aux_1">all_interf_regs_correct_aux_1</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_aux_2">all_interf_regs_correct_aux_2</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_aux_3">all_interf_regs_correct_aux_3</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_1">all_interf_regs_correct_1</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_2">all_interf_regs_correct_2</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.CSEproof.html#analysis_correct_entry">analysis_correct_entry</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#analysis_correct_N">analysis_correct_N</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#analysis_correct_1">analysis_correct_1</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Allocation.html#analyze">analyze</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Constprop.html#analyze">analyze</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.CSE.html#analyze">analyze</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Allocproof.html#analyze_correct">analyze_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Constpropproof.html#analyze_correct_1">analyze_correct_1</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#analyze_correct_2">analyze_correct_2</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#analyze_correct_3">analyze_correct_3</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Kildall.html#analyze_invariant">analyze_invariant</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#analyze_P">analyze_P</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="lib.Integers.html#and">and</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#and">and</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#and">and</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#andimm">andimm</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.PPCgen.html#andimm">andimm</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#andimm_correct">andimm_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Values.html#and_assoc">and_assoc</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#and_assoc">and_assoc</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_commut">and_commut</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#and_commut">and_commut</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#and_idem">and_idem</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_mone">and_mone</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_or_distrib">and_or_distrib</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_shl">and_shl</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_shru">and_shru</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_xor_distrib">and_xor_distrib</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_zero">and_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Parallelmove.html#appcons_length">appcons_length</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Maps.html#append">append</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#append_assoc_0">append_assoc_0</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#append_assoc_1">append_assoc_1</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#append_injective">append_injective</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#append_neutral_l">append_neutral_l</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#append_neutral_r">append_neutral_r</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Main.html#apply_partial">apply_partial</a> [definition, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#apply_total">apply_total</a> [definition, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#apply_total_transf_program">apply_total_transf_program</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Constprop.html#approx">approx</a> [inductive, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#Approx">Approx</a> [module, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#approx_regs">approx_regs</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#approx_regs_val_list">approx_regs_val_list</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Parallelmove.html#app_app">app_app</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_cons">app_cons</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_nil">app_nil</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_rewrite">app_rewrite</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_rewriter">app_rewriter</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_rewrite2">app_rewrite2</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Conventions.html#arguments_not_preserved">arguments_not_preserved</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Cminorgen.html#assign_variable">assign_variable</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#assign_variables">assign_variables</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.AST.html">AST</a> [library]<br/>
-<br/><br/><a name="global_B"></a><h2>B </h2>
-<a href="backend.Kildall.html#BACKWARD_DATAFLOW_SOLVER">BACKWARD_DATAFLOW_SOLVER</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#Backward_Dataflow_Solver">Backward_Dataflow_Solver</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#base_case_Pmov_dec">base_case_Pmov_dec</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Kildall.html#basic_block_list">basic_block_list</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#basic_block_map">basic_block_map</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#BBlock_solver">BBlock_solver</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#BBLOCK_SOLVER">BBLOCK_SOLVER</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#bbmap">bbmap</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.LTL.html#Bcall">Bcall</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bcond">Bcond</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bgetstack">Bgetstack</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bgoto">Bgoto</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="lib.Inclusion.html#bin">bin</a> [inductive, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.RTLgen.html#bind">bind</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Cminorgen.html#bind">bind</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.RTLgen.html#bind2">bind2</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Csharpminor.html#bind_parameters">bind_parameters</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#bind_parameters_cons">bind_parameters_cons</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminorgenproof.html#bind_parameters_length">bind_parameters_length</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Csharpminor.html#bind_parameters_nil">bind_parameters_nil</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="lib.Inclusion.html#bin_A">bin_A</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z">bits_of_Z</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_above">bits_of_Z_above</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_below">bits_of_Z_below</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_mone">bits_of_Z_mone</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_of_bits">bits_of_Z_of_bits</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_zero">bits_of_Z_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop">bitwise_binop</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_assoc">bitwise_binop_assoc</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_commut">bitwise_binop_commut</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_idem">bitwise_binop_idem</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_rol">bitwise_binop_rol</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_shl">bitwise_binop_shl</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_shru">bitwise_binop_shru</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.LTL.html#Bload">Bload</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#block">block</a> [inductive, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Values.html#block">block</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Mem.html#block_agree">block_agree</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_agree_refl">block_agree_refl</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_agree_sym">block_agree_sym</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_agree_trans">block_agree_trans</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents">block_contents</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_agree">block_contents_agree</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_exten">block_contents_exten</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_extends">block_contents_extends</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_inject">block_contents_inject</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_inject_incr">block_contents_inject_incr</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_cont_val">block_cont_val</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Values.html#bool_of_false_val">bool_of_false_val</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_false_val2">bool_of_false_val2</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_false_val_inv">bool_of_false_val_inv</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_true_val">bool_of_true_val</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_true_val2">bool_of_true_val2</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_true_val_inv">bool_of_true_val_inv</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_val">bool_of_val</a> [inductive, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_val_int_true">bool_of_val_int_true</a> [constructor, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.LTL.html#Bop">Bop</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="lib.Lattice.html#bot">bot</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#Bot">Bot</a> [constructor, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#bot">bot</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#bot">bot</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Sets.html#bot">bot</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#bot">bot</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#Bot_except">Bot_except</a> [constructor, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Lineartyping.html#bounds">bounds</a> [inductive, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Mem.html#bounds_free_block">bounds_free_block</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Lineartyping.html#bound_float_callee_save_pos">bound_float_callee_save_pos</a> [lemma, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#bound_float_local_pos">bound_float_local_pos</a> [lemma, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#bound_int_callee_save_pos">bound_int_callee_save_pos</a> [lemma, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#bound_int_local_pos">bound_int_local_pos</a> [lemma, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#bound_outgoing_pos">bound_outgoing_pos</a> [lemma, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Tunneling.html#branch_target">branch_target</a> [definition, in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Tunnelingproof.html#branch_target_characterization">branch_target_characterization</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Tunneling.html#branch_target_rec">branch_target_rec</a> [definition, in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Tunnelingproof.html#branch_target_rec_1">branch_target_rec_1</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#branch_target_rec_2">branch_target_rec_2</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.LTL.html#Breturn">Breturn</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bsetstack">Bsetstack</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bstore">Bstore</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Cminorgen.html#build_compilenv">build_compilenv</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<br/><br/><a name="global_C"></a><h2>C </h2>
-<a href="backend.Machabstr2mach.html#callstack">callstack</a> [definition, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Cminorgenproof.html#callstack">callstack</a> [definition, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_dom">callstack_dom</a> [inductive, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_dom_cons">callstack_dom_cons</a> [constructor, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_dom_diff">callstack_dom_diff</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_dom_incr">callstack_dom_incr</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_dom_less">callstack_dom_less</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_dom_nil">callstack_dom_nil</a> [constructor, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_exten">callstack_exten</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_function_entry">callstack_function_entry</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_function_return">callstack_function_return</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_get_parent">callstack_get_parent</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_get_slot">callstack_get_slot</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_init">callstack_init</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_invariant">callstack_invariant</a> [inductive, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_linked">callstack_linked</a> [inductive, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_linked_cons">callstack_linked_cons</a> [constructor, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_linked_nil">callstack_linked_nil</a> [constructor, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_linked_one">callstack_linked_one</a> [constructor, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_load">callstack_load</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_set_slot">callstack_set_slot</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_store">callstack_store</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_store_aux">callstack_store_aux</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_store_ok">callstack_store_ok</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.LTL.html#call_regs">call_regs</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Allocproof.html#call_regs_param_of_arg">call_regs_param_of_arg</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPC.html#CARRY">CARRY</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Csharpminor.html#cast">cast</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="lib.Integers.html#cast16signed">cast16signed</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cast16signed">cast16signed</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#cast16signed">cast16signed</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#cast16unsigned">cast16unsigned</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#cast16unsigned">cast16unsigned</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cast16unsigned">cast16unsigned</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast16unsigned_and">cast16unsigned_and</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cast16unsigned_and">cast16unsigned_and</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cast16_signed_equal_if_unsigned_equal">cast16_signed_equal_if_unsigned_equal</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast16_signed_idem">cast16_signed_idem</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast16_unsigned_idem">cast16_unsigned_idem</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast16_unsigned_signed">cast16_unsigned_signed</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#cast8signed">cast8signed</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#cast8signed">cast8signed</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cast8signed">cast8signed</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#cast8unsigned">cast8unsigned</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#cast8unsigned">cast8unsigned</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cast8unsigned">cast8unsigned</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8unsigned_and">cast8unsigned_and</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cast8unsigned_and">cast8unsigned_and</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cast8_signed_equal_if_unsigned_equal">cast8_signed_equal_if_unsigned_equal</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8_signed_idem">cast8_signed_idem</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8_signed_unsigned">cast8_signed_unsigned</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8_unsigned_idem">cast8_unsigned_idem</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8_unsigned_signed">cast8_unsigned_signed</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Op.html#Ccomp">Ccomp</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ccompf">Ccompf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ccompimm">Ccompimm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ccompu">Ccompu</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ccompuimm">Ccompuimm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cminor.html#CEcond">CEcond</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#CEcondition">CEcondition</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#CEfalse">CEfalse</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.AST.html#Ceq">Ceq</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Cminor.html#CEtrue">CEtrue</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.AST.html#Cge">Cge</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Cgt">Cgt</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="lib.Inclusion.html#check_all_leaves">check_all_leaves</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#check_all_leaves_sound">check_all_leaves_sound</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Coloring.html#check_coloring">check_coloring</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#check_coloring_1">check_coloring_1</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#check_coloring_1_correct">check_coloring_1_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloring.html#check_coloring_2">check_coloring_2</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#check_coloring_2_correct">check_coloring_2_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloring.html#check_coloring_3">check_coloring_3</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#check_coloring_3_correct">check_coloring_3_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Mem.html#check_cont">check_cont</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#check_cont_agree">check_cont_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#check_cont_false">check_cont_false</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#check_cont_inject">check_cont_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#check_cont_inv">check_cont_inv</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#check_cont_true">check_cont_true</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Integers.html#check_equal_on_range">check_equal_on_range</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#check_equal_on_range_correct">check_equal_on_range_correct</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Mach.html#chunk_of_type">chunk_of_type</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPC.html#Cint">Cint</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.AST.html#Cle">Cle</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Linearize.html#cleanup_code">cleanup_code</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearizetyping.html#cleanup_code_conservation">cleanup_code_conservation</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizetyping.html#cleanup_code_conservation_2">cleanup_code_conservation_2</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizeproof.html#cleanup_code_correct_1">cleanup_code_correct_1</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#cleanup_code_correct_2">cleanup_code_correct_2</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearize.html#cleanup_function">cleanup_function</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearizetyping.html#cleanup_function_conservation">cleanup_function_conservation</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizetyping.html#cleanup_function_conservation_2">cleanup_function_conservation_2</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizeproof.html#cleanup_function_correct">cleanup_function_correct</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.AST.html#Clt">Clt</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Op.html#Cmasknotzero">Cmasknotzero</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Cmaskzero">Cmaskzero</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstr.html">Cmconstr</a> [library]<br/>
-<a href="backend.Cmconstrproof.html">Cmconstrproof</a> [library]<br/>
-<a href="backend.Cminor.html">Cminor</a> [library]<br/>
-<a href="backend.Cminorgen.html">Cminorgen</a> [library]<br/>
-<a href="backend.Cminorgenproof.html">Cminorgenproof</a> [library]<br/>
-<a href="lib.Floats.html#cmp">cmp</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Cmconstr.html#cmp">cmp</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#cmp">cmp</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cmp">cmp</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#cmpf">cmpf</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#cmpf">cmpf</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmpf_ge">cmpf_ge</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmpf_is_bool">cmpf_is_bool</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmpf_le">cmpf_le</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmpu">cmpu</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#cmpu">cmpu</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#cmpu">cmpu</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cmpu_is_bool">cmpu_is_bool</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Floats.html#cmp_ge_gt_eq">cmp_ge_gt_eq</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Values.html#cmp_is_bool">cmp_is_bool</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Floats.html#cmp_le_lt_eq">cmp_le_lt_eq</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Values.html#cmp_mismatch">cmp_mismatch</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmp_mismatch_is_bool">cmp_mismatch_is_bool</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Floats.html#cmp_ne_eq">cmp_ne_eq</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.AST.html#Cne">Cne</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Op.html#Cnotcompf">Cnotcompf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.LTL.html#code">code</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.PPC.html#code">code</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.RTL.html#code">code</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Linear.html#code">code</a> [definition, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Mach.html#code">code</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPCgen.html#code_size">code_size</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof.html#code_tail">code_tail</a> [definition, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#code_tail_next">code_tail_next</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#code_tail_next_int">code_tail_next_int</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Coloring.html">Coloring</a> [library]<br/>
-<a href="backend.Coloringproof.html">Coloringproof</a> [library]<br/>
-<a href="lib.Maps.html#combine">combine</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#combine_commut">combine_commut</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Ordered.html#compare">compare</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#compare">compare</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#compare">compare</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.PPC.html#compare_float">compare_float</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#compare_float_spec">compare_float_spec</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPC.html#compare_sint">compare_sint</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#compare_sint_spec">compare_sint_spec</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPC.html#compare_uint">compare_uint</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#compare_uint_spec">compare_uint_spec</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.AST.html#comparison">comparison</a> [inductive, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Cminorgen.html#compilenv">compilenv</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminor.html#condexpr">condexpr</a> [inductive, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cmconstr.html#condexpr_of_expr">condexpr_of_expr</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Op.html#condition">condition</a> [inductive, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstr.html#conditionalexpr">conditionalexpr</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Constprop.html#cond_strength_reduction">cond_strength_reduction</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#cond_strength_reduction_cases">cond_strength_reduction_cases</a> [inductive, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#cond_strength_reduction_correct">cond_strength_reduction_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constprop.html#cond_strength_reduction_match">cond_strength_reduction_match</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.RTLtyping.html#consistent">consistent</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#consistent_not_eq">consistent_not_eq</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.PPC.html#constant">constant</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Constprop.html">Constprop</a> [library]<br/>
-<a href="backend.Constpropproof.html">Constpropproof</a> [library]<br/>
-<a href="backend.PPC.html#const_high">const_high</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#const_low">const_low</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Parallelmove.html#cons_replace">cons_replace</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.LTL.html#Cont">Cont</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Mem.html#Cont">Cont</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content">content</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#contentmap">contentmap</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#contentmap_agree">contentmap_agree</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#contentmap_inject">contentmap_inject</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#contentmap_inject_incr">contentmap_inject_incr</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject">content_inject</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_cont">content_inject_cont</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_datum16">content_inject_datum16</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_datum32">content_inject_datum32</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_datum64">content_inject_datum64</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_datum8">content_inject_datum8</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_incr">content_inject_incr</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_undef">content_inject_undef</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Linearizeproof.html#cont_for_outcome">cont_for_outcome</a> [inductive, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Conventions.html">Conventions</a> [library]<br/>
-<a href="lib.Coqlib.html">Coqlib</a> [library]<br/>
-<a href="backend.Coloringproof.html#correct_alloc_instr">correct_alloc_instr</a> [definition, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#correct_interf_alloc_instr">correct_interf_alloc_instr</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#correct_interf_instr">correct_interf_instr</a> [definition, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#correct_interf_instr_incl">correct_interf_instr_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.PPC.html#crbit">crbit</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgen.html#crbit_for_cond">crbit_for_cond</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#crbit_for_fcmp">crbit_for_fcmp</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#crbit_for_icmp">crbit_for_icmp</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPC.html#CRbit_0">CRbit_0</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CRbit_1">CRbit_1</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CRbit_2">CRbit_2</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CRbit_3">CRbit_3</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CR0_0">CR0_0</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CR0_1">CR0_1</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CR0_2">CR0_2</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CR0_3">CR0_3</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.CSE.html">CSE</a> [library]<br/>
-<a href="backend.CSEproof.html">CSEproof</a> [library]<br/>
-<a href="backend.Csharpminor.html">Csharpminor</a> [library]<br/>
-<a href="backend.Constprop.html#csr_case1">csr_case1</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#csr_case2">csr_case2</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#csr_default">csr_default</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.PPC.html#Csymbol_high_signed">Csymbol_high_signed</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Csymbol_high_unsigned">Csymbol_high_unsigned</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Csymbol_low_signed">Csymbol_low_signed</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Csymbol_low_unsigned">Csymbol_low_unsigned</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CTR">CTR</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<br/><br/><a name="global_D"></a><h2>D </h2>
-<a href="backend.Constprop.html#D">D</a> [module, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Kildall.html#Dataflow_Solver">Dataflow_Solver</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#DATAFLOW_SOLVER">DATAFLOW_SOLVER</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Mem.html#Datum16">Datum16</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Datum32">Datum32</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Datum64">Datum64</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Datum8">Datum8</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.RTLtyping.html#decode">decode</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#def">def</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLtyping.html#definite">definite</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#definite_included">definite_included</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Conventions.html#destroyed_at_call">destroyed_at_call</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#destroyed_at_call_regs">destroyed_at_call_regs</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Locations.html#diff">diff</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#diff_dec">diff_dec</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#diff_not_eq">diff_not_eq</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#diff_sym">diff_sym</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Kildall.html#discard_top_worklist_invariant">discard_top_worklist_invariant</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#disc1">disc1</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#disc2">disc2</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#disjoint">disjoint</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#disjoint_cons_left">disjoint_cons_left</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#disjoint_cons_right">disjoint_cons_right</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#disjoint_notin">disjoint_notin</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#disjoint_sym">disjoint_sym</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#disjoint_tmp__noTmp">disjoint_tmp__noTmp</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#dis_dsttmp1_pnilnil">dis_dsttmp1_pnilnil</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#dis_srctmp1_pnilnil">dis_srctmp1_pnilnil</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="lib.Floats.html#div">div</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Values.html#divf">divf</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#divf">divf</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#divs">divs</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#divs">divs</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#divs">divs</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#divs_pow2">divs_pow2</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#divs_pow2">divs_pow2</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#divu">divu</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#divu">divu</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#divu">divu</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#divu_cases">divu_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#divu_case1">divu_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#divu_default">divu_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#divu_match">divu_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#divu_pow2">divu_pow2</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#divu_pow2">divu_pow2</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1src_inv">Done_notmp1src_inv</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1src_invf">Done_notmp1src_invf</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1src_invpp">Done_notmp1src_invpp</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1src_res">Done_notmp1src_res</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1_inv">Done_notmp1_inv</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1_invf">Done_notmp1_invf</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1_invpp">Done_notmp1_invpp</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1_res">Done_notmp1_res</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp3_inv">Done_notmp3_inv</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp3_invf">Done_notmp3_invf</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp3_invpp">Done_notmp3_invpp</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp3_res">Done_notmp3_res</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_well_formed">Done_well_formed</a> [definition, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Conventions.html#drop1">drop1</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#drop2">drop2</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Kildall.html#DS">DS</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Constprop.html#DS">DS</a> [module, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Linearize.html#DS">DS</a> [module, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Allocation.html#DS">DS</a> [module, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Parallelmove.html#dstep">dstep</a> [inductive, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp">dstepp</a> [inductive, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp_refl">dstepp_refl</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp_sameExec">dstepp_sameExec</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp_stepp">dstepp_stepp</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp_trans">dstepp_trans</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_inv">dstep_inv</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_inv_getdst">dstep_inv_getdst</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_nop">dstep_nop</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_pop">dstep_pop</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_pop_loop">dstep_pop_loop</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_push">dstep_push</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_start">dstep_start</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_step">dstep_step</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#dst_tmp2_res">dst_tmp2_res</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#dst_tmp2_step">dst_tmp2_step</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#dst_tmp2_stepf">dst_tmp2_stepf</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#dst_tmp2_stepp">dst_tmp2_stepp</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<br/><br/><a name="global_E"></a><h2>E </h2>
-<a href="backend.Csharpminor.html#Eaddrof">Eaddrof</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Eassign">Eassign</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Eassign">Eassign</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ecall">Ecall</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Ecall">Ecall</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Econdition">Econdition</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Econdition">Econdition</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#Econs">Econs</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Econs">Econs</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="lib.union_find.html#ELEMENT">ELEMENT</a> [module, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.Sets.html#elements">elements</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#elements">elements</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elements_complete">elements_complete</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Sets.html#elements_complete">elements_complete</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#elements_correct">elements_correct</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Sets.html#elements_correct">elements_correct</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#elements_keys_norepet">elements_keys_norepet</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Csharpminor.html#Elet">Elet</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Elet">Elet</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#Eletvar">Eletvar</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Eletvar">Eletvar</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Eload">Eload</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Eload">Eload</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="lib.Maps.html#elt">elt</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTLtyping.html#elt">elt</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Sets.html#elt">elt</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.union_find.html#elt">elt</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#elt">elt</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#elt">elt</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.Maps.html#elt">elt</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt">elt</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt">elt</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt_eq">elt_eq</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt_eq">elt_eq</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt_eq">elt_eq</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt_eq">elt_eq</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#EMap">EMap</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Sets.html#empty">empty</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#empty">empty</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.union_find.html#empty">empty</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.RTLtyping.html#empty">empty</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Globalenvs.html#empty">empty</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Mem.html#empty">empty</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#empty_block">empty_block</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Csharpminor.html#empty_env">empty_env</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Machabstr.html#empty_frame">empty_frame</a> [definition, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.InterfGraph.html#empty_graph">empty_graph</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.CSE.html#empty_numbering">empty_numbering</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#empty_numbering_satisfiable">empty_numbering_satisfiable</a> [lemma, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.RTLtyping.html#encode">encode</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#encode_decode">encode_decode</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#encode_injective">encode_injective</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Csharpminor.html#Enil">Enil</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Enil">Enil</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Allocproof.html#entrypoint_function_translated">entrypoint_function_translated</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Linearize.html#enumerate">enumerate</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearizeproof.html#enumerate_complete">enumerate_complete</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#enumerate_head">enumerate_head</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#enumerate_norepet">enumerate_norepet</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Csharpminor.html#env">env</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Parallelmove.html#Env">Env</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cminor.html#env">env</a> [definition, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Eop">Eop</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Eop">Eop</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Constprop.html#eq">eq</a> [lemma, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Mach.html#eq">eq</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="lib.Ordered.html#eq">eq</a> [definition, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.RTLtyping.html#eq">eq</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Lattice.html#eq">eq</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#eq">eq</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.CSEproof.html#eq">eq</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.Lattice.html#eq">eq</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#eq">eq</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Locations.html#eq">eq</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#eq">eq</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#eq">eq</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#eq">eq</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Ordered.html#eq">eq</a> [definition, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.Registers.html#eq">eq</a> [definition, in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="lib.Maps.html#eq">eq</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Ordered.html#eq">eq</a> [definition, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.PPC.html#eq">eq</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Integers.html#eq">eq</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm">eqm</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod">eqmod</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_add">eqmod_add</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_mod">eqmod_mod</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_mod_eq">eqmod_mod_eq</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_mult">eqmod_mult</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_neg">eqmod_neg</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_refl">eqmod_refl</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_refl2">eqmod_refl2</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_small_eq">eqmod_small_eq</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_sub">eqmod_sub</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_sym">eqmod_sym</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_trans">eqmod_trans</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_256_unsigned_repr">eqmod_256_unsigned_repr</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_65536_unsigned_repr">eqmod_65536_unsigned_repr</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_add">eqm_add</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_mult">eqm_mult</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_neg">eqm_neg</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_refl">eqm_refl</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_refl2">eqm_refl2</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_samerepr">eqm_samerepr</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_signed_unsigned">eqm_signed_unsigned</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_small_eq">eqm_small_eq</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_sub">eqm_sub</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_sym">eqm_sym</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_trans">eqm_trans</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_unsigned_repr">eqm_unsigned_repr</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_unsigned_repr_l">eqm_unsigned_repr_l</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_unsigned_repr_r">eqm_unsigned_repr_r</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Maps.html#EQUALITY_TYPE">EQUALITY_TYPE</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTLtyping.html#equal_eq">equal_eq</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Integers.html#equal_on_range">equal_on_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.CSEproof.html#equation_evals_to_holds_1">equation_evals_to_holds_1</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#equation_evals_to_holds_2">equation_evals_to_holds_2</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSE.html#equation_holds">equation_holds</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Values.html#eq_block">eq_block</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#eq_dec">eq_dec</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Floats.html#eq_dec">eq_dec</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Integers.html#eq_false">eq_false</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.CSE.html#eq_list_valnum">eq_list_valnum</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Ordered.html#eq_refl">eq_refl</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_refl">eq_refl</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_refl">eq_refl</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.CSE.html#eq_rhs">eq_rhs</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Integers.html#eq_spec">eq_spec</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Ordered.html#eq_sym">eq_sym</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_sym">eq_sym</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Integers.html#eq_sym">eq_sym</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Ordered.html#eq_sym">eq_sym</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_trans">eq_trans</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_trans">eq_trans</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_trans">eq_trans</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Integers.html#eq_true">eq_true</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.CSE.html#eq_valnum">eq_valnum</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Floats.html#eq_zero_false">eq_zero_false</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#eq_zero_true">eq_zero_true</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.RTLgen.html#Error">Error</a> [constructor, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLtyping.html#error">error</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLgen.html#error">error</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.PPC.html#Error">Error</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.RTLtyping.html#error_inconsistent">error_inconsistent</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Cminor.html#Estore">Estore</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Estore">Estore</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_absfloat">eval_absfloat</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_add">eval_add</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_addf">eval_addf</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_addimm">eval_addimm</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_addimm_ptr">eval_addimm_ptr</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_addressing">eval_addressing</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_addressing">eval_addressing</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_addressing_preserved">eval_addressing_preserved</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_addressing_total">eval_addressing_total</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_addressing_weaken">eval_addressing_weaken</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_add_ptr">eval_add_ptr</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_add_ptr_2">eval_add_ptr_2</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_and">eval_and</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_andimm">eval_andimm</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_base_condition_of_expr">eval_base_condition_of_expr</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cast16signed">eval_cast16signed</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cast16unsigned">eval_cast16unsigned</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cast8signed">eval_cast8signed</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cast8unsigned">eval_cast8unsigned</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmp">eval_cmp</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmpf">eval_cmpf</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmpu">eval_cmpu</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmp_null_l">eval_cmp_null_l</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmp_null_r">eval_cmp_null_r</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmp_ptr">eval_cmp_ptr</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_compare_null">eval_compare_null</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#eval_compare_null">eval_compare_null</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#eval_compare_null_weaken">eval_compare_null_weaken</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_condition">eval_condition</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_conditionalexpr_false">eval_conditionalexpr_false</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_conditionalexpr_true">eval_conditionalexpr_true</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_condition_of_expr">eval_condition_of_expr</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_condition_total">eval_condition_total</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_condition_total_is_bool">eval_condition_total_is_bool</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_condition_weaken">eval_condition_weaken</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_divf">eval_divf</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_divs">eval_divs</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_divu">eval_divu</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_divu_base">eval_divu_base</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Csharpminor.html#eval_Evar">eval_Evar</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#eval_Evar">eval_Evar</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#eval_expr">eval_expr</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#eval_expr">eval_expr</a> [inductive, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminorgenproof.html#eval_exprlist_prop">eval_exprlist_prop</a> [definition, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#eval_expr_prop">eval_expr_prop</a> [definition, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_floatofint">eval_floatofint</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_floatofintu">eval_floatofintu</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#eval_funcall_prop">eval_funcall_prop</a> [definition, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_intoffloat">eval_intoffloat</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_lift">eval_lift</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_lift_expr">eval_lift_expr</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_load">eval_load</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mods">eval_mods</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_modu">eval_modu</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mod_aux">eval_mod_aux</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mul">eval_mul</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mulf">eval_mulf</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mulimm">eval_mulimm</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mulimm_base">eval_mulimm_base</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_negate_condition">eval_negate_condition</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_negfloat">eval_negfloat</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_negint">eval_negint</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_notbool">eval_notbool</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_notbool_base">eval_notbool_base</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_notint">eval_notint</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_operation">eval_operation</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#eval_operation">eval_operation</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#eval_operation_preserved">eval_operation_preserved</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_operation_total">eval_operation_total</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_operation_weaken">eval_operation_weaken</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_or">eval_or</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_rolm">eval_rolm</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shl">eval_shl</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shlimm">eval_shlimm</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shr">eval_shr</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shru">eval_shru</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shruimm">eval_shruimm</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_singleoffloat">eval_singleoffloat</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition">eval_static_condition</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_cases">eval_static_condition_cases</a> [inductive, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case1">eval_static_condition_case1</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case2">eval_static_condition_case2</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case3">eval_static_condition_case3</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case4">eval_static_condition_case4</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case5">eval_static_condition_case5</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case6">eval_static_condition_case6</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case7">eval_static_condition_case7</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case8">eval_static_condition_case8</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#eval_static_condition_correct">eval_static_condition_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_default">eval_static_condition_default</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_match">eval_static_condition_match</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation">eval_static_operation</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_cases">eval_static_operation_cases</a> [inductive, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case1">eval_static_operation_case1</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case11">eval_static_operation_case11</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case12">eval_static_operation_case12</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case13">eval_static_operation_case13</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case14">eval_static_operation_case14</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case15">eval_static_operation_case15</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case16">eval_static_operation_case16</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case17">eval_static_operation_case17</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case18">eval_static_operation_case18</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case19">eval_static_operation_case19</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case2">eval_static_operation_case2</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case20">eval_static_operation_case20</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case21">eval_static_operation_case21</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case22">eval_static_operation_case22</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case23">eval_static_operation_case23</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case24">eval_static_operation_case24</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case25">eval_static_operation_case25</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case26">eval_static_operation_case26</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case27">eval_static_operation_case27</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case28">eval_static_operation_case28</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case29">eval_static_operation_case29</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case3">eval_static_operation_case3</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case30">eval_static_operation_case30</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case31">eval_static_operation_case31</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case32">eval_static_operation_case32</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case33">eval_static_operation_case33</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case34">eval_static_operation_case34</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case35">eval_static_operation_case35</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case36">eval_static_operation_case36</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case37">eval_static_operation_case37</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case38">eval_static_operation_case38</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case39">eval_static_operation_case39</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case4">eval_static_operation_case4</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case40">eval_static_operation_case40</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case41">eval_static_operation_case41</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case42">eval_static_operation_case42</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case43">eval_static_operation_case43</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case44">eval_static_operation_case44</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case45">eval_static_operation_case45</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case46">eval_static_operation_case46</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case47">eval_static_operation_case47</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case6">eval_static_operation_case6</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case7">eval_static_operation_case7</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case8">eval_static_operation_case8</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case9">eval_static_operation_case9</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#eval_static_operation_correct">eval_static_operation_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_default">eval_static_operation_default</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_match">eval_static_operation_match</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_store">eval_store</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_sub">eval_sub</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_subf">eval_subf</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_sub_ptr_int">eval_sub_ptr_int</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_sub_ptr_ptr">eval_sub_ptr_ptr</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_xor">eval_xor</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cminor.html#Evar">Evar</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Evar">Evar</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Parallelmove.html#exec">exec</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.LTL.html#exec_Bgetstack">exec_Bgetstack</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_blocks_Bgoto_inv">exec_blocks_Bgoto_inv</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.LTL.html#exec_blocks_extends">exec_blocks_extends</a> [lemma, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_blocks_prop">exec_blocks_prop</a> [definition, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_blocks_prop">exec_blocks_prop</a> [definition, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_blocks_valid_outcome">exec_blocks_valid_outcome</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_block_Bgoto_inv">exec_block_Bgoto_inv</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_block_prop">exec_block_prop</a> [definition, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_block_prop">exec_block_prop</a> [definition, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_function_body_prop">exec_function_body_prop</a> [definition, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_function_body_prop">exec_function_body_prop</a> [definition, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Machtyping.html#exec_function_body_prop">exec_function_body_prop</a> [definition, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_function_body_prop_">exec_function_body_prop_</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_function_equiv">exec_function_equiv</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Stackingproof.html#exec_function_prop">exec_function_prop</a> [definition, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Machtyping.html#exec_function_prop">exec_function_prop</a> [definition, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_function_prop">exec_function_prop</a> [definition, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Constpropproof.html#exec_function_prop">exec_function_prop</a> [definition, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_function_prop">exec_function_prop</a> [definition, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_function_prop">exec_function_prop</a> [definition, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.CSEproof.html#exec_function_prop">exec_function_prop</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_function_prop">exec_function_prop</a> [definition, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Allocproof.html#exec_function_prop">exec_function_prop</a> [definition, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_function_prop_">exec_function_prop_</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTLtyping.html#exec_function_subject_reduction">exec_function_subject_reduction</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Cmconstrproof.html#exec_ifthenelse_false">exec_ifthenelse_false</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#exec_ifthenelse_true">exec_ifthenelse_true</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.RTL.html#exec_Iload">exec_Iload</a> [constructor, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.RTL.html#exec_Iload'">exec_Iload'</a> [lemma, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.RTL.html#exec_Inop">exec_Inop</a> [constructor, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Machabstr.html#exec_instr">exec_instr</a> [inductive, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.RTL.html#exec_instr">exec_instr</a> [inductive, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.LTL.html#exec_instr">exec_instr</a> [inductive, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Linear.html#exec_instr">exec_instr</a> [inductive, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Mach.html#exec_instr">exec_instr</a> [inductive, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPC.html#exec_instr">exec_instr</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_instrs_Bgoto_inv">exec_instrs_Bgoto_inv</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instrs_extends">exec_instrs_extends</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instrs_extends_rec">exec_instrs_extends_rec</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Stackingproof.html#exec_instrs_incl">exec_instrs_incl</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_instrs_incl">exec_instrs_incl</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instrs_incr">exec_instrs_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Machtyping.html#exec_instrs_link_invariant">exec_instrs_link_invariant</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Allocproof_aux.html#exec_instrs_pmov">exec_instrs_pmov</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.RTL.html#exec_instrs_present">exec_instrs_present</a> [lemma, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Allocproof.html#exec_instrs_prop">exec_instrs_prop</a> [definition, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_instrs_prop">exec_instrs_prop</a> [definition, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_instrs_prop">exec_instrs_prop</a> [definition, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.CSEproof.html#exec_instrs_prop">exec_instrs_prop</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Constpropproof.html#exec_instrs_prop">exec_instrs_prop</a> [definition, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_instrs_prop">exec_instrs_prop</a> [definition, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_extends">exec_instr_extends</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_extends_rec">exec_instr_extends_rec</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_instr_incl">exec_instr_incl</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#exec_instr_incl">exec_instr_incl</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_incr">exec_instr_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_in_s2">exec_instr_in_s2</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Machtyping.html#exec_instr_link_invariant">exec_instr_link_invariant</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_not_halt">exec_instr_not_halt</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTL.html#exec_instr_present">exec_instr_present</a> [lemma, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Allocproof.html#exec_instr_prop">exec_instr_prop</a> [definition, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_instr_prop">exec_instr_prop</a> [definition, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machtyping.html#exec_instr_prop">exec_instr_prop</a> [definition, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Constpropproof.html#exec_instr_prop">exec_instr_prop</a> [definition, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.CSEproof.html#exec_instr_prop">exec_instr_prop</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_instr_prop">exec_instr_prop</a> [definition, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Stackingproof.html#exec_instr_prop">exec_instr_prop</a> [definition, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_instr_prop">exec_instr_prop</a> [definition, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_instr_prop">exec_instr_prop</a> [definition, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTLtyping.html#exec_instr_subject_reduction">exec_instr_subject_reduction</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Allocproof_aux.html#exec_instr_update">exec_instr_update</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.RTL.html#exec_Iop">exec_Iop</a> [constructor, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.RTL.html#exec_Iop'">exec_Iop'</a> [lemma, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Linear.html#exec_Lgetstack">exec_Lgetstack</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mcall_prop">exec_Mcall_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mcond_false_prop">exec_Mcond_false_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mcond_true_prop">exec_Mcond_true_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Mach.html#exec_Mgetparam">exec_Mgetparam</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mgetparam_prop">exec_Mgetparam_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Mach.html#exec_Mgetstack">exec_Mgetstack</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Machabstr.html#exec_Mgetstack">exec_Mgetstack</a> [constructor, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Stackingproof.html#exec_Mgetstack'">exec_Mgetstack'</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mgetstack_prop">exec_Mgetstack_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mgoto_prop">exec_Mgoto_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Mach.html#exec_Mlabel">exec_Mlabel</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Machabstr.html#exec_Mlabel">exec_Mlabel</a> [constructor, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mlabel_prop">exec_Mlabel_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mload_prop">exec_Mload_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mop_prop">exec_Mop_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Mach.html#exec_Msetstack">exec_Msetstack</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Stackingproof.html#exec_Msetstack'">exec_Msetstack'</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Msetstack_prop">exec_Msetstack_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mstore_prop">exec_Mstore_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Machabstr.html#exec_mutual_induction">exec_mutual_induction</a> [lemma, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.PPC.html#exec_one">exec_one</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_one_prop">exec_one_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Csharpminor.html#exec_program">exec_program</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.LTL.html#exec_program">exec_program</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Cminor.html#exec_program">exec_program</a> [definition, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.RTL.html#exec_program">exec_program</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Mach.html#exec_program">exec_program</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Machabstr.html#exec_program">exec_program</a> [definition, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Linear.html#exec_program">exec_program</a> [definition, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.PPC.html#exec_program">exec_program</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_program_equiv">exec_program_equiv</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.PPC.html#exec_refl">exec_refl</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_refl_prop">exec_refl_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTL.html#exec_step">exec_step</a> [lemma, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.PPC.html#exec_step">exec_step</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#exec_steps">exec_steps</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#exec_step_intro">exec_step_intro</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Cminorgenproof.html#exec_stmtlist_prop">exec_stmtlist_prop</a> [definition, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#exec_stmt_prop">exec_stmt_prop</a> [definition, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight">exec_straight</a> [inductive, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_straight_exec_prop">exec_straight_exec_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_one">exec_straight_one</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_refl">exec_straight_refl</a> [constructor, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_step">exec_straight_step</a> [constructor, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_straight_steps">exec_straight_steps</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_straight_steps_1">exec_straight_steps_1</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_straight_steps_2">exec_straight_steps_2</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_three">exec_straight_three</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_trans">exec_straight_trans</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_two">exec_straight_two</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPC.html#exec_trans">exec_trans</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_trans_prop">exec_trans_prop</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Csharpminor.html#expr">expr</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#expr">expr</a> [inductive, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#exprlist">exprlist</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#exprlist">exprlist</a> [inductive, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.RTLgenproof1.html#expr_condexpr_exprlist_ind">expr_condexpr_exprlist_ind</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="lib.Maps.html#exten">exten</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Mem.html#extends">extends</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#extends_refl">extends_refl</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#extend_inject">extend_inject</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#extend_inject_incr">extend_inject_incr</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Coqlib.html#extensionality">extensionality</a> [axiom, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<br/><br/><a name="global_F"></a><h2>F </h2>
-<a href="backend.Globalenvs.html#find_funct">find_funct</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.LTL.html#find_function">find_function</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Mach.html#find_function">find_function</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.RTL.html#find_function">find_function</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Linear.html#find_function">find_function</a> [definition, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Allocproof.html#find_function2">find_function2</a> [definition, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_find_funct_ptr">find_funct_find_funct_ptr</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_inv">find_funct_inv</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_prop">find_funct_prop</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr">find_funct_ptr</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr_inv">find_funct_ptr_inv</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr_prop">find_funct_ptr_prop</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr_transf">find_funct_ptr_transf</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr_transf_partial">find_funct_ptr_transf_partial</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_transf">find_funct_transf</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_transf_partial">find_funct_transf_partial</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.PPC.html#find_instr">find_instr</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof.html#find_instr_in">find_instr_in</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#find_instr_tail">find_instr_tail</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Mach.html#find_label">find_label</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPCgenproof.html#find_label">find_label</a> [definition, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Linear.html#find_label">find_label</a> [definition, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_cleanup_code">find_label_cleanup_code</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.PPCgenproof.html#find_label_goto_label">find_label_goto_label</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#find_label_incl">find_label_incl</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_lin">find_label_lin</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_lin_block">find_label_lin_block</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_lin_rec">find_label_lin_rec</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Stackingproof.html#find_label_transl_code">find_label_transl_code</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_unique">find_label_unique</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.RTLgen.html#find_letvar">find_letvar</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_letvar_incr">find_letvar_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_letvar_in_map">find_letvar_in_map</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_letvar_not_mutated">find_letvar_not_mutated</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_letvar_valid">find_letvar_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.CSE.html#find_load">find_load</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#find_load_correct">find_load_correct</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSE.html#find_op">find_op</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#find_op_correct">find_op_correct</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSE.html#find_rhs">find_rhs</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#find_rhs_correct">find_rhs_correct</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Globalenvs.html#find_symbol">find_symbol</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_symbol_inv">find_symbol_inv</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Op.html#find_symbol_offset">find_symbol_offset</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Globalenvs.html#find_symbol_transf">find_symbol_transf</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_symbol_transf_partial">find_symbol_transf_partial</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.CSE.html#find_valnum_rhs">find_valnum_rhs</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#find_valnum_rhs_correct">find_valnum_rhs_correct</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.RTLgen.html#find_var">find_var</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_var_incr">find_var_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_var_in_map">find_var_in_map</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_var_not_mutated">find_var_not_mutated</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_var_valid">find_var_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Kildall.html#fixpoint">fixpoint</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint">fixpoint</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint">fixpoint</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_entry">fixpoint_entry</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_entry">fixpoint_entry</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_entry">fixpoint_entry</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_incr">fixpoint_incr</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_invariant">fixpoint_invariant</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_solution">fixpoint_solution</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_solution">fixpoint_solution</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_solution">fixpoint_solution</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Stacking.html#FI_arg">FI_arg</a> [constructor, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#FI_local">FI_local</a> [constructor, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#FI_saved_float">FI_saved_float</a> [constructor, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#FI_saved_int">FI_saved_int</a> [constructor, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="lib.Inclusion.html#flatten">flatten</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#flatten_aux">flatten_aux</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#flatten_aux_valid_A">flatten_aux_valid_A</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#flatten_valid_A">flatten_valid_A</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Floats.html#float">float</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#Float">Float</a> [module, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.PPCgen.html#floatcomp">floatcomp</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#floatcomp_correct">floatcomp_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Values.html#floatofint">floatofint</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Floats.html#floatofint">floatofint</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Cmconstr.html#floatofint">floatofint</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#floatofintu">floatofintu</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#floatofintu">floatofintu</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Floats.html#floatofintu">floatofintu</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html">Floats</a> [library]<br/>
-<a href="backend.Lineartyping.html#float_callee_save">float_callee_save</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#float_callee_save_bound">float_callee_save_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Conventions.html#float_callee_save_norepet">float_callee_save_norepet</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#float_callee_save_not_destroyed">float_callee_save_not_destroyed</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#float_callee_save_regs">float_callee_save_regs</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#float_callee_save_type">float_callee_save_type</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Lineartyping.html#float_local">float_local</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#float_local_slot_bound">float_local_slot_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Conventions.html#float_param_regs">float_param_regs</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Csharpminor.html#fn_params_names">fn_params_names</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#fn_variables">fn_variables</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#fn_vars_names">fn_vars_names</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="lib.Sets.html#fold">fold</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#fold">fold</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTLtyping.html#fold2">fold2</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Maps.html#fold_spec">fold_spec</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Sets.html#fold_spec">fold_spec</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Sets.html#for_all">for_all</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Sets.html#for_all_spec">for_all_spec</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct">Fpmov_correct</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correctMoves">Fpmov_correctMoves</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct1">Fpmov_correct1</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct2">Fpmov_correct2</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct_ext">Fpmov_correct_ext</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct_IT3">Fpmov_correct_IT3</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct_map">Fpmov_correct_map</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.PPC.html#FPR0">FPR0</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR1">FPR1</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR10">FPR10</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR11">FPR11</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR12">FPR12</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR13">FPR13</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR14">FPR14</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR15">FPR15</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR16">FPR16</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR17">FPR17</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR18">FPR18</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR19">FPR19</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR2">FPR2</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR20">FPR20</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR21">FPR21</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR22">FPR22</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR23">FPR23</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR24">FPR24</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR25">FPR25</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR26">FPR26</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR27">FPR27</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR28">FPR28</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR29">FPR29</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR3">FPR3</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR30">FPR30</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR31">FPR31</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR4">FPR4</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR5">FPR5</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR6">FPR6</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR7">FPR7</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR8">FPR8</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR9">FPR9</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FR">FR</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Cminorgenproof.html#frame">frame</a> [inductive, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Machabstr.html#frame">frame</a> [definition, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Stacking.html#frame_env">frame_env</a> [inductive, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#frame_index">frame_index</a> [inductive, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match">frame_match</a> [inductive, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_alloc">frame_match_alloc</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_exten">frame_match_exten</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_free">frame_match_free</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_get_slot">frame_match_get_slot</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_intro">frame_match_intro</a> [constructor, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_load">frame_match_load</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_new">frame_match_new</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_set_slot">frame_match_set_slot</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_store">frame_match_store</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_store_ok">frame_match_store_ok</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_store_stack_other">frame_match_store_stack_other</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Mem.html#free">free</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_empty_bounds">free_empty_bounds</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_extends">free_extends</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_first_inject">free_first_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_first_list_inject">free_first_list_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_inject">free_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_list">free_list</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_snd_inject">free_snd_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPC.html#freg">freg</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#freg_eq">freg_eq</a> [lemma, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgen.html#freg_of">freg_of</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#freg_of_is_data_reg">freg_of_is_data_reg</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#freg_of_not_FPR13">freg_of_not_FPR13</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#freg_val">freg_val</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Mem.html#fresh_block_alloc">fresh_block_alloc</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Locations.html#FT1">FT1</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#FT2">FT2</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#FT3">FT3</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Mach.html#function">function</a> [inductive, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Csharpminor.html#function">function</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.RTL.html#function">function</a> [inductive, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.LTL.html#function">function</a> [inductive, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Cminor.html#function">function</a> [inductive, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Linear.html#function">function</a> [inductive, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Globalenvs.html#functions_globalenv">functions_globalenv</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Constpropproof.html#functions_translated">functions_translated</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#functions_translated">functions_translated</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.PPCgenproof.html#functions_translated">functions_translated</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Allocproof.html#functions_translated">functions_translated</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Linearizeproof.html#functions_translated">functions_translated</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Stackingproof.html#functions_translated">functions_translated</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.CSEproof.html#functions_translated">functions_translated</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#functions_translated">functions_translated</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#functions_translated">functions_translated</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#functions_translated_no_overflow">functions_translated_no_overflow</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#functions_translated_2">functions_translated_2</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Lineartyping.html#function_bounds">function_bounds</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Cminorgenproof.html#function_entry_ok">function_entry_ok</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Linearizeproof.html#function_ptr_translated">function_ptr_translated</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Allocproof.html#function_ptr_translated">function_ptr_translated</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Stackingproof.html#function_ptr_translated">function_ptr_translated</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#function_ptr_translated">function_ptr_translated</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#function_ptr_translated">function_ptr_translated</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Constpropproof.html#function_ptr_translated">function_ptr_translated</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#function_ptr_translated">function_ptr_translated</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.CSEproof.html#funct_ptr_translated">funct_ptr_translated</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Locations.html#F1">F1</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F10">F10</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F14">F14</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F15">F15</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F16">F16</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F17">F17</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F18">F18</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F19">F19</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F2">F2</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#f2ind">f2ind</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#f2ind'">f2ind'</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#F20">F20</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F21">F21</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F22">F22</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F23">F23</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F24">F24</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F25">F25</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F26">F26</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F27">F27</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F28">F28</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F29">F29</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F3">F3</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F30">F30</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F31">F31</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F4">F4</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F5">F5</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F6">F6</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F7">F7</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F8">F8</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F9">F9</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<br/><br/><a name="global_G"></a><h2>G </h2>
-<a href="lib.Maps.html#gcombine">gcombine</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#ge">ge</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.CSE.html#ge">ge</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Lattice.html#ge">ge</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge">ge</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge">ge</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge">ge</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#gempty">gempty</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Cminor.html#genv">genv</a> [definition, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.LTL.html#genv">genv</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Globalenvs.html#Genv">Genv</a> [module, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.PPC.html#genv">genv</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Globalenvs.html#GENV">GENV</a> [module, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Csharpminor.html#genv">genv</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Globalenvs.html#genv">genv</a> [inductive, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.RTL.html#genv">genv</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Mach.html#genv">genv</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Linear.html#genv">genv</a> [definition, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="lib.Maps.html#get">get</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#get">get</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#get">get</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Parallelmove.html#Get">Get</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#get">get</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Lattice.html#get">get</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#get">get</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Parallelmove.html#get">get</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLtyping.html#get">get</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#getdst">getdst</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#getdst_add">getdst_add</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#getdst_app">getdst_app</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#getdst_f">getdst_f</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#getdst_lists2moves">getdst_lists2moves</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#getdst_map">getdst_map</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Mem.html#getN">getN</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_agree">getN_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_init">getN_init</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_inject">getN_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_setN_mismatch">getN_setN_mismatch</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_setN_other">getN_setN_other</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_setN_overlap">getN_setN_overlap</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_setN_same">getN_setN_same</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc">getsrc</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#getsrcdst_app">getsrcdst_app</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc_add">getsrc_add</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc_add1">getsrc_add1</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc_app">getsrc_app</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#getsrc_f">getsrc_f</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc_map">getsrc_map</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLtyping.html#get_add_1">get_add_1</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#get_add_2">get_add_2</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Lattice.html#get_bot">get_bot</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.RTLtyping.html#get_empty">get_empty</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#get_noWrite">get_noWrite</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#get_pexec_id_noWrite">get_pexec_id_noWrite</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Machabstr.html#get_slot">get_slot</a> [inductive, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Stackingproof.html#get_slot_index">get_slot_index</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Machabstr.html#get_slot_intro">get_slot_intro</a> [constructor, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Stackingproof.html#get_slot_ok">get_slot_ok</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="lib.Lattice.html#get_top">get_top</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Parallelmove.html#get_update">get_update</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#get_update_diff">get_update_diff</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#get_update_id">get_update_id</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#get_update_ndiff">get_update_ndiff</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Maps.html#get_xget_h">get_xget_h</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#ge_bot">ge_bot</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_bot">ge_bot</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge_bot">ge_bot</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#ge_bot">ge_bot</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge_bot">ge_bot</a> [lemma, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge_lub_left">ge_lub_left</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge_lub_left">ge_lub_left</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Constprop.html#ge_lub_left">ge_lub_left</a> [lemma, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge_lub_left">ge_lub_left</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_lub_left">ge_lub_left</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge_lub_right">ge_lub_right</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#ge_refl">ge_refl</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge_refl">ge_refl</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#ge_refl">ge_refl</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_refl">ge_refl</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge_refl">ge_refl</a> [lemma, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge_top">ge_top</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge_top">ge_top</a> [lemma, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge_top">ge_top</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_top">ge_top</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_trans">ge_trans</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge_trans">ge_trans</a> [lemma, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Sets.html#ge_trans">ge_trans</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#ge_trans">ge_trans</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_trans">ge_trans</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#gi">gi</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gi">gi</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gi">gi</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gleaf">gleaf</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Globalenvs.html#globalenv">globalenv</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html">Globalenvs</a> [library]<br/>
-<a href="backend.Globalenvs.html#globalenv_initmem">globalenv_initmem</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="lib.Maps.html#gmap">gmap</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gmap">gmap</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gmap">gmap</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gmap">gmap</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Kildall.html#good_state">good_state</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.PPC.html#goto_label">goto_label</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR0">GPR0</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR1">GPR1</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR10">GPR10</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR11">GPR11</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR12">GPR12</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR13">GPR13</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR14">GPR14</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR15">GPR15</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR16">GPR16</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR17">GPR17</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR18">GPR18</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR19">GPR19</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR2">GPR2</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR20">GPR20</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR21">GPR21</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR22">GPR22</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR23">GPR23</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR24">GPR24</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR25">GPR25</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR26">GPR26</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR27">GPR27</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR28">GPR28</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR29">GPR29</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR3">GPR3</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR30">GPR30</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR31">GPR31</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR4">GPR4</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR5">GPR5</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR6">GPR6</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR7">GPR7</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR8">GPR8</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR9">GPR9</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#gpr_or_zero">gpr_or_zero</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#gpr_or_zero_not_zero">gpr_or_zero_not_zero</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#gpr_or_zero_zero">gpr_or_zero_zero</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.InterfGraph.html#graph">graph</a> [inductive, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#graph_coloring">graph_coloring</a> [axiom, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.InterfGraph.html#graph_incl">graph_incl</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloringproof.html#graph_incl_refl">graph_incl_refl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#graph_incl_trans">graph_incl_trans</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="lib.Maps.html#gro">gro</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#grs">grs</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsident">gsident</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsident">gsident</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsident">gsident</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gso">gso</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#gso">gso</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#gso">gso</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gso">gso</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#gso">gso</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#gso">gso</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gss">gss</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gss">gss</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#gss">gss</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#gss">gss</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#gss">gss</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#gss">gss</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsspec">gsspec</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsspec">gsspec</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsspec">gsspec</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsspec">gsspec</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<br/><br/><a name="global_H"></a><h2>H </h2>
-<a href="lib.Integers.html#half_modulus">half_modulus</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#has_type">has_type</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#has_type_list">has_type_list</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Parallelmove.html#head_but_last">head_but_last</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Mem.html#high_bound">high_bound</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#high_bound_alloc">high_bound_alloc</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#high_bound_free">high_bound_free</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#high_bound_store">high_bound_store</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPC.html#high_half_signed">high_half_signed</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#high_half_signed_type">high_half_signed_type</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#high_half_signed_zero">high_half_signed_zero</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPC.html#high_half_unsigned">high_half_unsigned</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#high_half_unsigned_type">high_half_unsigned_type</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#high_half_unsigned_zero">high_half_unsigned_zero</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgen.html#high_s">high_s</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#high_u">high_u</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<br/><br/><a name="global_I"></a><h2>I </h2>
-<a href="backend.AST.html#ident">ident</a> [definition, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="lib.union_find.html#identify">identify</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_aux_decomp">identify_aux_decomp</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base">identify_base</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_a_maps_to_b">identify_base_a_maps_to_b</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_b_canon">identify_base_b_canon</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_order_wf">identify_base_order_wf</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_repr">identify_base_repr</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_repr_order">identify_base_repr_order</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_sameclass_1">identify_base_sameclass_1</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_sameclass_2">identify_base_sameclass_2</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.Cminorgen.html#Identset">Identset</a> [module, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.AST.html#ident_eq">ident_eq</a> [definition, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Cmconstr.html#ifthenelse">ifthenelse</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Maps.html#IMap">IMap</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.RTLtyping.html#included">included</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_consistent">included_consistent</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_identify">included_identify</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_mapped">included_mapped</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_mapped_forall">included_mapped_forall</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_refl">included_refl</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_trans">included_trans</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Inclusion.html">Inclusion</a> [library]<br/>
-<a href="lib.Inclusion.html#inclusion_theorem">inclusion_theorem</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Coqlib.html#incl_app_inv_l">incl_app_inv_l</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#incl_app_inv_r">incl_app_inv_r</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#incl_cons_inv">incl_cons_inv</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Alloctyping_aux.html#incl_dst">incl_dst</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Machtyping.html#incl_find_label">incl_find_label</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Alloctyping_aux.html#incl_nil">incl_nil</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="lib.Coqlib.html#incl_same_head">incl_same_head</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Alloctyping_aux.html#incl_src">incl_src</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Locations.html#Incoming">Incoming</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.LTLtyping.html#Incoming">Incoming</a> [inductive, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.Lineartyping.html#Incoming">Incoming</a> [inductive, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Locations.html#index">index</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#index">index</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#index">index</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#IndexedMreg">IndexedMreg</a> [module, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#INDEXED_TYPE">INDEXED_TYPE</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Stackingproof.html#index_arg_valid">index_arg_valid</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_diff">index_diff</a> [definition, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Conventions.html#index_float_callee_save">index_float_callee_save</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_float_callee_save_inj">index_float_callee_save_inj</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_float_callee_save_pos">index_float_callee_save_pos</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_float_callee_save_pos2">index_float_callee_save_pos2</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="lib.Maps.html#index_inj">index_inj</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#index_inj">index_inj</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#index_inj">index_inj</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Conventions.html#index_int_callee_save">index_int_callee_save</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_int_callee_save_inj">index_int_callee_save_inj</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_int_callee_save_pos">index_int_callee_save_pos</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_int_callee_save_pos2">index_int_callee_save_pos2</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Stackingproof.html#index_local_valid">index_local_valid</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_saved_float_valid">index_saved_float_valid</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_saved_int_valid">index_saved_int_valid</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_val">index_val</a> [definition, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_valid">index_valid</a> [definition, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_val_init_frame">index_val_init_frame</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Parallelmove.html#Indst_noOverlap_aux">Indst_noOverlap_aux</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Ingetsrc_swap">Ingetsrc_swap</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Ingetsrc_swap2">Ingetsrc_swap2</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Maps.html#init">init</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#init">init</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#init">init</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#init">init</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Kildall.html#initial_state_invariant">initial_state_invariant</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Globalenvs.html#initmem_nullptr">initmem_nullptr</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#initmem_undef">initmem_undef</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Machabstr.html#init_frame">init_frame</a> [definition, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.RTLgen.html#init_mapping">init_mapping</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#init_mapping_wf">init_mapping_wf</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Globalenvs.html#init_mem">init_mem</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#init_mem_transf">init_mem_transf</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#init_mem_transf_partial">init_mem_transf_partial</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.RTL.html#init_regs">init_regs</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.RTLgen.html#init_state">init_state</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#init_state_wf">init_state_wf</a> [lemma, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="lib.Lattice.html#Inj">Inj</a> [constructor, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Mem.html#inject_incr">inject_incr</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#inject_incr_refl">inject_incr_refl</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#inject_incr_trans">inject_incr_trans</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.RTL.html#Inop">Inop</a> [constructor, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="lib.Inclusion.html#insert_bin">insert_bin</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#insert_bin_included">insert_bin_included</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv">insert_lenv</a> [inductive, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv_lookup1">insert_lenv_lookup1</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv_lookup2">insert_lenv_lookup2</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv_S">insert_lenv_S</a> [constructor, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv_0">insert_lenv_0</a> [constructor, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Linear.html#instruction">instruction</a> [inductive, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.PPC.html#instruction">instruction</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.RTL.html#instruction">instruction</a> [inductive, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Mach.html#instruction">instruction</a> [inductive, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.RTLgenproof1.html#instr_at_incr">instr_at_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="lib.Integers.html#int">int</a> [inductive, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Int">Int</a> [module, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html">Integers</a> [library]<br/>
-<a href="backend.InterfGraph.html#interfere">interfere</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloringproof.html#interfere_incl">interfere_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#interfere_mreg">interfere_mreg</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloringproof.html#interfere_mreg_incl">interfere_mreg_incl</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#interfere_sym">interfere_sym</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html">InterfGraph</a> [library]<br/>
-<a href="backend.Coloring.html#interf_graph">interf_graph</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#interf_graph_correct_1">interf_graph_correct_1</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#interf_graph_correct_2">interf_graph_correct_2</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#interf_graph_correct_3">interf_graph_correct_3</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Cmconstr.html#intoffloat">intoffloat</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Floats.html#intoffloat">intoffloat</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Values.html#intoffloat">intoffloat</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Constprop.html#intval">intval</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#intval_correct">intval_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#int_add_no_overflow">int_add_no_overflow</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Lineartyping.html#int_callee_save">int_callee_save</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#int_callee_save_bound">int_callee_save_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Conventions.html#int_callee_save_norepet">int_callee_save_norepet</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#int_callee_save_not_destroyed">int_callee_save_not_destroyed</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#int_callee_save_regs">int_callee_save_regs</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#int_callee_save_type">int_callee_save_type</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#int_float_callee_save_disjoint">int_float_callee_save_disjoint</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Lineartyping.html#int_local">int_local</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#int_local_slot_bound">int_local_slot_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="lib.Integers.html#int_of_one_bits">int_of_one_bits</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Conventions.html#int_param_regs">int_param_regs</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Cmconstrproof.html#inv_eval_Eop_0">inv_eval_Eop_0</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#inv_eval_Eop_1">inv_eval_Eop_1</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#inv_eval_Eop_2">inv_eval_Eop_2</a> [lemma, in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Mem.html#in_bounds">in_bounds</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#in_bounds_exten">in_bounds_exten</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#in_bounds_holds">in_bounds_holds</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#in_bounds_inject">in_bounds_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Allocproof_aux.html#in_cons_noteq">in_cons_noteq</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Kildall.html#in_incr">in_incr</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#in_incr_refl">in_incr_refl</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#in_incr_trans">in_incr_trans</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#In_Indst">In_Indst</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#in_move__in_srcdst">in_move__in_srcdst</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#In_norepet">In_norepet</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Locations.html#in_notin_diff">in_notin_diff</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#In_noTmp_notempo">In_noTmp_notempo</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Inclusion.html#in_or_insert_bin">in_or_insert_bin</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Machabstr2mach.html#in_or_notin_callstack">in_or_notin_callstack</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="lib.Inclusion.html#In_permute_app_head">In_permute_app_head</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Integers.html#in_range">in_range</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#in_range_range">in_range_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Inclusion.html#in_remove_head">in_remove_head</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Parallelmove.html#In_SD_diff">In_SD_diff</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#In_SD_diff'">In_SD_diff'</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#In_SD_no_o">In_SD_no_o</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#in_split_move">in_split_move</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="lib.Maps.html#in_xelements">in_xelements</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#in_xkeys">in_xkeys</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.PPC.html#IR">IR</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#ireg">ireg</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#ireg_eq">ireg_eq</a> [lemma, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgen.html#ireg_of">ireg_of</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#ireg_of_is_data_reg">ireg_of_is_data_reg</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#ireg_of_not_GPR1">ireg_of_not_GPR1</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#ireg_of_not_GPR2">ireg_of_not_GPR2</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#ireg_val">ireg_val</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Values.html#isfalse_not_istrue">isfalse_not_istrue</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#istrue_not_isfalse">istrue_not_isfalse</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Kildall.html#is_basic_block_head">is_basic_block_head</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Values.html#is_bool">is_bool</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.PPCgenproof1.html#is_data_reg">is_data_reg</a> [definition, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="lib.Integers.html#is_false">is_false</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#is_false">is_false</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Tunneling.html#is_goto_block">is_goto_block</a> [definition, in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Tunnelingproof.html#is_goto_block_correct">is_goto_block_correct</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.PPC.html#is_label">is_label</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#is_label">is_label</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Linear.html#is_label">is_label</a> [definition, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.PPC.html#is_label_correct">is_label_correct</a> [lemma, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#is_label_correct">is_label_correct</a> [lemma, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Linear.html#is_label_correct">is_label_correct</a> [lemma, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Op.html#is_move_operation">is_move_operation</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#is_move_operation_correct">is_move_operation_correct</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Integers.html#is_power2">is_power2</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#is_power2_correct">is_power2_correct</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#is_power2_range">is_power2_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#is_power2_rng">is_power2_rng</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#is_rlw_mask">is_rlw_mask</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#is_rlw_mask_rec">is_rlw_mask_rec</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail">is_tail</a> [inductive, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_cons">is_tail_cons</a> [constructor, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_cons_left">is_tail_cons_left</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_exec_instr">is_tail_exec_instr</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_exec_instrs">is_tail_exec_instrs</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_find_label">is_tail_find_label</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_in">is_tail_in</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_refl">is_tail_refl</a> [constructor, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.CSE.html#is_trivial_op">is_trivial_op</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Integers.html#is_true">is_true</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#is_true">is_true</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Kildall.html#iterate">iterate</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#iterate_base">iterate_base</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#iterate_incr">iterate_incr</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#iterate_solution">iterate_solution</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#iterate_step">iterate_step</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#iter_step">iter_step</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Locations.html#IT1">IT1</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#IT2">IT2</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#IT3">IT3</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<br/><br/><a name="global_K"></a><h2>K </h2>
-<a href="backend.Kildall.html">Kildall</a> [library]<br/>
-<a href="backend.CSE.html#kill_loads">kill_loads</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#kill_load_eqs">kill_load_eqs</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#kill_load_eqs_incl">kill_load_eqs_incl</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#kill_load_eqs_ops">kill_load_eqs_ops</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#kill_load_satisfiable">kill_load_satisfiable</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<br/><br/><a name="global_L"></a><h2>L </h2>
-<a href="backend.Kildall.html#L">L</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Linear.html#label">label</a> [definition, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.PPC.html#label">label</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#label">label</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Linearizeproof.html#label_in_lin_block">label_in_lin_block</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#label_in_lin_rec">label_in_lin_rec</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.PPC.html#label_pos">label_pos</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof.html#label_pos_code_tail">label_pos_code_tail</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Parallelmove.html#last">last</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#last_app">last_app</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#last_cons">last_cons</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#last_replace">last_replace</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Lattice.html">Lattice</a> [library]<br/>
-<a href="backend.Linearize.html#lbl">lbl</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearize.html#lbl">lbl</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="lib.Lattice.html#LBoolean">LBoolean</a> [module, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Linear.html#Lcall">Lcall</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lcond">Lcond</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="lib.Maps.html#Leaf">Leaf</a> [constructor, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Inclusion.html#leaf">leaf</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#leaf">leaf</a> [constructor, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#leaf">leaf</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#leaf">leaf</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Allocproof.html#length_addr_args">length_addr_args</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Parallelmove.html#length_app">length_app</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof.html#length_cond_args">length_cond_args</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#length_op_args">length_op_args</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Parallelmove.html#length_replace">length_replace</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cminor.html#letenv">letenv</a> [definition, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#letenv">letenv</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.RTLtyping.html#let_fold_args_res">let_fold_args_res</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Lattice.html#LFlat">LFlat</a> [module, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Linear.html#Lgetstack">Lgetstack</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lgoto">Lgoto</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Cmconstr.html#lift">lift</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#lift_condexpr">lift_condexpr</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#lift_expr">lift_expr</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#lift_exprlist">lift_exprlist</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Linear.html">Linear</a> [library]<br/>
-<a href="backend.Linearize.html">Linearize</a> [library]<br/>
-<a href="backend.Linearizeproof.html">Linearizeproof</a> [library]<br/>
-<a href="backend.Linearizetyping.html">Linearizetyping</a> [library]<br/>
-<a href="backend.Linearize.html#linearize_block">linearize_block</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearizetyping.html#linearize_block_incl">linearize_block_incl</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearize.html#linearize_body">linearize_body</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearize.html#linearize_function">linearize_function</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Lineartyping.html">Lineartyping</a> [library]<br/>
-<a href="backend.Machtyping.html#link_invariant">link_invariant</a> [definition, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Parallelmove.html#listsLoc2Moves">listsLoc2Moves</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocation.html#listsLoc2Moves">listsLoc2Moves</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="lib.Coqlib.html#list_append_map">list_append_map</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint">list_disjoint</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint_cons_left">list_disjoint_cons_left</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint_cons_right">list_disjoint_cons_right</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint_notin">list_disjoint_notin</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint_sym">list_disjoint_sym</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_forall2">list_forall2</a> [inductive, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_forall2_cons">list_forall2_cons</a> [constructor, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_forall2_imply">list_forall2_imply</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_forall2_nil">list_forall2_nil</a> [constructor, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_in_map_inv">list_in_map_inv</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_length_map">list_length_map</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_map_compose">list_map_compose</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_map_exten">list_map_exten</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_map_norepet">list_map_norepet</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_map_nth">list_map_nth</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet">list_norepet</a> [inductive, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_append">list_norepet_append</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_append_left">list_norepet_append_left</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_append_right">list_norepet_append_right</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_cons">list_norepet_cons</a> [constructor, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_dec">list_norepet_dec</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_nil">list_norepet_nil</a> [constructor, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Allocproof.html#live0">live0</a> [definition, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Linear.html#Llabel">Llabel</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lload">Lload</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Mem.html#load">load</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cmconstr.html#load">load</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.CSE.html#Load">Load</a> [constructor, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.PPCgen.html#loadimm">loadimm</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#loadimm_correct">loadimm_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgen.html#loadind">loadind</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#loadind_aux">loadind_aux</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#loadind_aux_correct">loadind_aux_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#loadind_correct">loadind_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Mem.html#loadv">loadv</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#loadv_inject">loadv_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgenproof.html#loadv_8_signed_unsigned">loadv_8_signed_unsigned</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPC.html#load1">load1</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#load2">load2</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mem.html#load_agree">load_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_alloc_other">load_alloc_other</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_alloc_same">load_alloc_same</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_contentmap_agree">load_contentmap_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_contents">load_contents</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_contents_init">load_contents_init</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_contents_inject">load_contents_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_extends">load_extends</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_free">load_free</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#load_freelist">load_freelist</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#load_from_alloc_is_undef">load_from_alloc_is_undef</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#load_inject">load_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_inv">load_inv</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_in_bounds">load_in_bounds</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Values.html#load_result">load_result</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cminorgenproof.html#load_result_idem">load_result_idem</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#load_result_inject">load_result_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#load_result_normalized">load_result_normalized</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#load_result_ty">load_result_ty</a> [lemma, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Mach.html#load_stack">load_stack</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mem.html#load_store_contents_mismatch">load_store_contents_mismatch</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_contents_other">load_store_contents_other</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_contents_overlap">load_store_contents_overlap</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_contents_same">load_store_contents_same</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_other">load_store_other</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_same">load_store_same</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Locations.html#loc">loc</a> [inductive, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#Loc">Loc</a> [module, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#Local">Local</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Csharpminor.html#local_variable">local_variable</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Locations.html">Locations</a> [library]<br/>
-<a href="backend.Locations.html#Locmap">Locmap</a> [module, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.LTL.html#locset">locset</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Linear.html#locset">locset</a> [definition, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Conventions.html#locs_acceptable">locs_acceptable</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#locs_acceptable_disj_temporaries">locs_acceptable_disj_temporaries</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Alloctyping.html#locs_read_ok">locs_read_ok</a> [definition, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#locs_write_ok">locs_write_ok</a> [definition, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Conventions.html#loc_acceptable">loc_acceptable</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Allocproof.html#loc_acceptable_noteq_diff">loc_acceptable_noteq_diff</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#loc_acceptable_notin_notin">loc_acceptable_notin_notin</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments">loc_arguments</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_acceptable">loc_arguments_acceptable</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_bounded">loc_arguments_bounded</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_length">loc_arguments_length</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_norepet">loc_arguments_norepet</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_not_temporaries">loc_arguments_not_temporaries</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_rec">loc_arguments_rec</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_type">loc_arguments_type</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_argument_acceptable">loc_argument_acceptable</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Coloring.html#loc_is_acceptable">loc_is_acceptable</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#loc_is_acceptable_correct">loc_is_acceptable_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Conventions.html#loc_parameters">loc_parameters</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_parameters_not_temporaries">loc_parameters_not_temporaries</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_parameters_type">loc_parameters_type</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Alloctyping.html#loc_read_ok">loc_read_ok</a> [definition, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Conventions.html#loc_result">loc_result</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_result_acceptable">loc_result_acceptable</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_result_type">loc_result_type</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Alloctyping.html#loc_write_ok">loc_write_ok</a> [definition, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Linear.html#Lop">Lop</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Mem.html#low_bound">low_bound</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#low_bound_alloc">low_bound_alloc</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#low_bound_free">low_bound_free</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#low_bound_store">low_bound_store</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPC.html#low_half_signed">low_half_signed</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_half_signed_type">low_half_signed_type</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_half_unsigned">low_half_unsigned</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_half_unsigned_type">low_half_unsigned_type</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_high_half_signed">low_high_half_signed</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_high_half_unsigned">low_high_half_unsigned</a> [axiom, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#low_high_s">low_high_s</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#low_high_u">low_high_u</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#low_high_u_xor">low_high_u_xor</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgen.html#low_s">low_s</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#low_u">low_u</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="lib.Lattice.html#LPMap">LPMap</a> [module, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.PPC.html#LR">LR</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Linear.html#Lreturn">Lreturn</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lsetstack">Lsetstack</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lstore">Lstore</a> [constructor, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="lib.Integers.html#lt">lt</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Ordered.html#lt">lt</a> [definition, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt">lt</a> [definition, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt">lt</a> [definition, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.LTL.html">LTL</a> [library]<br/>
-<a href="backend.LTLtyping.html">LTLtyping</a> [library]<br/>
-<a href="lib.Integers.html#ltu">ltu</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Ordered.html#lt_not_eq">lt_not_eq</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_not_eq">lt_not_eq</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_not_eq">lt_not_eq</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_trans">lt_trans</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_trans">lt_trans</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_trans">lt_trans</a> [lemma, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Lattice.html#lub">lub</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#lub">lub</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#lub">lub</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#lub">lub</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#lub">lub</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#lub_commut">lub_commut</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#lub_commut">lub_commut</a> [lemma, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#lub_commut">lub_commut</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#lub_commut">lub_commut</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#lub_commut">lub_commut</a> [lemma, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Csharpminor.html#LVarray">LVarray</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#LVscalar">LVscalar</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<br/><br/><a name="global_M"></a><h2>M </h2>
-<a href="backend.Mach.html">Mach</a> [library]<br/>
-<a href="backend.Machabstr.html">Machabstr</a> [library]<br/>
-<a href="backend.Machabstr2mach.html">Machabstr2mach</a> [library]<br/>
-<a href="backend.Machtyping.html">Machtyping</a> [library]<br/>
-<a href="backend.Main.html">Main</a> [library]<br/>
-<a href="lib.Sets.html#MakeSet">MakeSet</a> [module, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Constprop.html#make_addimm">make_addimm</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#make_addimm_correct">make_addimm_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constprop.html#make_andimm">make_andimm</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#make_andimm_correct">make_andimm_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cminorgen.html#make_cast">make_cast</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_cast_correct">make_cast_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Stacking.html#make_env">make_env</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Cminorgen.html#make_load">make_load</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_load_correct">make_load_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Constprop.html#make_mulimm">make_mulimm</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#make_mulimm_correct">make_mulimm_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cminorgen.html#make_op">make_op</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_op_correct">make_op_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Constprop.html#make_orimm">make_orimm</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#make_orimm_correct">make_orimm_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Kildall.html#make_predecessors">make_predecessors</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#make_predecessors_correct">make_predecessors_correct</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Constprop.html#make_shlimm">make_shlimm</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#make_shlimm_correct">make_shlimm_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constprop.html#make_shrimm">make_shrimm</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#make_shrimm_correct">make_shrimm_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constprop.html#make_shruimm">make_shruimm</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#make_shruimm_correct">make_shruimm_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cminorgen.html#make_stackaddr">make_stackaddr</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_stackaddr_correct">make_stackaddr_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgen.html#make_store">make_store</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_store_correct">make_store_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Constprop.html#make_xorimm">make_xorimm</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#make_xorimm_correct">make_xorimm_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="lib.Maps.html#map">map</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#map">map</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#map">map</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#map">map</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#MAP">MAP</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.union_find.html#MAP">MAP</a> [module, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.RTLtyping.html#mapped">mapped</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#mapped_included_consistent">mapped_included_consistent</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#mapped_list_included">mapped_list_included</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLgen.html#mapping">mapping</a> [inductive, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="lib.Maps.html">Maps</a> [library]<br/>
-<a href="backend.Alloctyping_aux.html#map_f_getsrc_getdst">map_f_getsrc_getdst</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#map_inv">map_inv</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.RTLgenproof1.html#map_wf">map_wf</a> [inductive, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#map_wf_incr">map_wf_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack">match_callstack</a> [inductive, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_left">match_callstack_alloc_left</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_other">match_callstack_alloc_other</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_right">match_callstack_alloc_right</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_variables">match_callstack_alloc_variables</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_variables_rec">match_callstack_alloc_variables_rec</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_freelist">match_callstack_freelist</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_freelist_rec">match_callstack_freelist_rec</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_incr_bound">match_callstack_incr_bound</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_mapped">match_callstack_mapped</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_match_globalenvs">match_callstack_match_globalenvs</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_store_above">match_callstack_store_above</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_store_local">match_callstack_store_local</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_store_local_unchanged">match_callstack_store_local_unchanged</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env">match_env</a> [inductive, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env">match_env</a> [inductive, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_alloc_other">match_env_alloc_other</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_alloc_same">match_env_alloc_same</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_empty">match_env_empty</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_exten">match_env_exten</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_extensional">match_env_extensional</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_find_reg">match_env_find_reg</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_freelist">match_env_freelist</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_invariant">match_env_invariant</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_letvar">match_env_letvar</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_store_above">match_env_store_above</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_store_local">match_env_store_local</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_store_mapped">match_env_store_mapped</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_update_temp">match_env_update_temp</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_update_var">match_env_update_var</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_globalenvs">match_globalenvs</a> [inductive, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_globalenvs_init">match_globalenvs_init</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_init_env_init_reg">match_init_env_init_reg</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof.html#match_return_outcome">match_return_outcome</a> [definition, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#match_return_reg">match_return_reg</a> [definition, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_set_locals">match_set_locals</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_set_params_init_regs">match_set_params_init_regs</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_var">match_var</a> [inductive, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_instrs">max_over_instrs</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#max_over_instrs_bound">max_over_instrs_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_list">max_over_list</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#max_over_list_bound">max_over_list_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_list_pos">max_over_list_pos</a> [lemma, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_regs_of_funct">max_over_regs_of_funct</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#max_over_regs_of_funct_bound">max_over_regs_of_funct_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_regs_of_funct_pos">max_over_regs_of_funct_pos</a> [lemma, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_regs_of_instr">max_over_regs_of_instr</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_slots_of_funct">max_over_slots_of_funct</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#max_over_slots_of_funct_bound">max_over_slots_of_funct_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_slots_of_funct_pos">max_over_slots_of_funct_pos</a> [lemma, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_slots_of_instr">max_over_slots_of_instr</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="lib.Integers.html#max_signed">max_signed</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#max_unsigned">max_unsigned</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Mach.html#Mcall">Mcall</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mcond">Mcond</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Cminorgenproof.html#mcs_cons">mcs_cons</a> [constructor, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#mcs_nil">mcs_nil</a> [constructor, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#mem">mem</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Sets.html#mem">mem</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Mem.html">Mem</a> [library]<br/>
-<a href="backend.RTLtyping.html#member">member</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#member_correct">member_correct</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Mem.html#meminj">meminj</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.AST.html#memory_chunk">memory_chunk</a> [inductive, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Mem.html#memory_size">memory_size</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Globalenvs.html#mem_add_globals_transf">mem_add_globals_transf</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="lib.Sets.html#mem_add_other">mem_add_other</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Sets.html#mem_add_same">mem_add_same</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.InterfGraph.html#mem_add_tail">mem_add_tail</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Mem.html#mem_chunk">mem_chunk</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Sets.html#mem_empty">mem_empty</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Mem.html#mem_exten">mem_exten</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#mem_inject">mem_inject</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Sets.html#mem_remove_other">mem_remove_other</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Sets.html#mem_remove_same">mem_remove_same</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Machabstr.html#mem_type">mem_type</a> [definition, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="lib.Sets.html#mem_union">mem_union</a> [lemma, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Parallelmove.html#mesure">mesure</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.AST.html#Mfloat32">Mfloat32</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mfloat64">Mfloat64</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Mach.html#Mgetparam">Mgetparam</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mgetstack">Mgetstack</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mgoto">Mgoto</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.AST.html#Mint16signed">Mint16signed</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mint16unsigned">Mint16unsigned</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mint32">Mint32</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mint8signed">Mint8signed</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mint8unsigned">Mint8unsigned</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="lib.Integers.html#min_signed">min_signed</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#mkint_eq">mkint_eq</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLtyping.html#mk_env">mk_env</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Mach.html#Mlabel">Mlabel</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mload">Mload</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="lib.Integers.html#mods">mods</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#mods">mods</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#mods">mods</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mods_divs">mods_divs</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mods_divs">mods_divs</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#modu">modu</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#modu">modu</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#modu">modu</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#modulus">modulus</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#modulus_pos">modulus_pos</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#modu_and">modu_and</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#modu_divu">modu_divu</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#modu_divu">modu_divu</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#modu_divu_Euclid">modu_divu_Euclid</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#modu_pow2">modu_pow2</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#mod_aux">mod_aux</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#mod_in_range">mod_in_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLgen.html#mon">mon</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="lib.Integers.html#mone">mone</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#mone_max_unsigned">mone_max_unsigned</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Mach.html#Mop">Mop</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.RTLgen.html#more_likely">more_likely</a> [axiom, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Parallelmove.html#Move">Move</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Moves">Moves</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#move_types_res">move_types_res</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Alloctyping_aux.html#move_types_stepf">move_types_stepf</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Locations.html#mreg">mreg</a> [inductive, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Lineartyping.html#mreg_bounded">mreg_bounded</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Locations.html#mreg_eq">mreg_eq</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Linearizetyping.html#mreg_is_bounded">mreg_is_bounded</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Locations.html#mreg_type">mreg_type</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Mach.html#Mreturn">Mreturn</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Msetstack">Msetstack</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mstore">Mstore</a> [constructor, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="lib.Floats.html#mul">mul</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Integers.html#mul">mul</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#mul">mul</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#mul">mul</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#mulf">mulf</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#mulf">mulf</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm">mulimm</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_base">mulimm_base</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_cases">mulimm_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_case1">mulimm_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_case2">mulimm_case2</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_default">mulimm_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_match">mulimm_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Kildall.html#multiple_predecessors">multiple_predecessors</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="lib.Integers.html#mul_add_distr_l">mul_add_distr_l</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mul_add_distr_l">mul_add_distr_l</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mul_add_distr_r">mul_add_distr_r</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mul_add_distr_r">mul_add_distr_r</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mul_assoc">mul_assoc</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mul_assoc">mul_assoc</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#mul_cases">mul_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_case1">mul_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_case2">mul_case2</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#mul_commut">mul_commut</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mul_commut">mul_commut</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#mul_default">mul_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_match">mul_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_match_aux">mul_match_aux</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#mul_one">mul_one</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#mul_pow2">mul_pow2</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mul_pow2">mul_pow2</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mul_zero">mul_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLgen.html#mutated_condexpr">mutated_condexpr</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#mutated_expr">mutated_expr</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#mutated_exprlist">mutated_exprlist</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#mutated_reg">mutated_reg</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#mutated_reg_in_map">mutated_reg_in_map</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLtyping.html#mymap">mymap</a> [module, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#myreg">myreg</a> [module, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#myT">myT</a> [inductive, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<br/><br/><a name="global_N"></a><h2>N </h2>
-<a href="backend.Op.html#n">n</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Inclusion.html#nat_le_bool">nat_le_bool</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Values.html#neg">neg</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#neg">neg</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Floats.html#neg">neg</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Values.html#negate_cmp">negate_cmp</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#negate_cmp">negate_cmp</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#negate_cmpf_eq">negate_cmpf_eq</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#negate_cmpu">negate_cmpu</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#negate_cmpu">negate_cmpu</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#negate_cmp_mismatch">negate_cmp_mismatch</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.AST.html#negate_comparison">negate_comparison</a> [definition, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Op.html#negate_condition">negate_condition</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Values.html#negf">negf</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#negfloat">negfloat</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#negint">negint</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#neg_add_distr">neg_add_distr</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#neg_add_distr">neg_add_distr</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#neg_mul_distr_l">neg_mul_distr_l</a> [axiom, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#neg_mul_distr_r">neg_mul_distr_r</a> [axiom, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#neg_repr">neg_repr</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#neg_zero">neg_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#neg_zero">neg_zero</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Parallelmove.html#neq_is_neq">neq_is_neq</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLgen.html#new_reg">new_reg</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_fresh">new_reg_fresh</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_incr">new_reg_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_not_in_map">new_reg_not_in_map</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_not_mutated">new_reg_not_mutated</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_return_ok">new_reg_return_ok</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_valid">new_reg_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPC.html#nextinstr">nextinstr</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#nextinstr_inv">nextinstr_inv</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#nextinstr_set_preg">nextinstr_set_preg</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#nil">nil</a> [definition, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Maps.html#NIndexed">NIndexed</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#NMap">NMap</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#Node">Node</a> [constructor, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTL.html#node">node</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.LTL.html#node">node</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="lib.Inclusion.html#node">node</a> [constructor, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Locations.html#non_overlap_diff">non_overlap_diff</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#NoOverlap">NoOverlap</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap">noOverlap</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlapaux_insert">noOverlapaux_insert</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlapaux_swap2">noOverlapaux_swap2</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_aux">noOverlap_aux</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_auxpop">noOverlap_auxpop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_auxPop">noOverlap_auxPop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_aux_app">noOverlap_aux_app</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_Front0">noOverlap_Front0</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_head">noOverlap_head</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_insert">noOverlap_insert</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_movBack">noOverlap_movBack</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_movBack0">noOverlap_movBack0</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_movFront">noOverlap_movFront</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_nil">noOverlap_nil</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_Pop">noOverlap_Pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_pop">noOverlap_pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_right">noOverlap_right</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_swap">noOverlap_swap</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noO_diff">noO_diff</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#noO_list_pnilnil">noO_list_pnilnil</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#noRead">noRead</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noRead_app">noRead_app</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noRead_by_path">noRead_by_path</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#norepet">norepet</a> [inductive, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#norepet_cons">norepet_cons</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#norepet_nil">norepet_nil</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Allocproof_aux.html#norepet_SD">norepet_SD</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="lib.Integers.html#not">not</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#notbool">notbool</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#notbool">notbool</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#notbool">notbool</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#notbool_base">notbool_base</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#notbool_idem2">notbool_idem2</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#notbool_idem3">notbool_idem3</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#notbool_isfalse_istrue">notbool_isfalse_istrue</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#notbool_istrue_isfalse">notbool_istrue_isfalse</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#notbool_is_bool">notbool_is_bool</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#notbool_negb_1">notbool_negb_1</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#notbool_negb_2">notbool_negb_2</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#notbool_xor">notbool_xor</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Parallelmove.html#notemporary">notemporary</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#notin">notin</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#notindst_nW">notindst_nW</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Values.html#notint">notint</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#notint">notint</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_cases">notint_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_case1">notint_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_case2">notint_case2</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_case3">notint_case3</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_default">notint_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_match">notint_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Machabstr2mach.html#notin_callstack">notin_callstack</a> [inductive, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#notin_callstack_cons">notin_callstack_cons</a> [constructor, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#notin_callstack_nil">notin_callstack_nil</a> [constructor, in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Locations.html#notin_disjoint">notin_disjoint</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#notin_not_in">notin_not_in</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp">noTmp</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast">noTmpLast</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_lastnoTmp">noTmpLast_lastnoTmp</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_Pop">noTmpLast_Pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_pop">noTmpLast_pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_popBack">noTmpLast_popBack</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_push">noTmpLast_push</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_tmpLast">noTmpLast_tmpLast</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpL_diff">noTmpL_diff</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_app">noTmp_app</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_append">noTmp_append</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmP_noOverlap_aux">noTmP_noOverlap_aux</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_noReadTmp">noTmp_noReadTmp</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_noTmpLast">noTmp_noTmpLast</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_pop">noTmp_pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Constprop.html#Novalue">Novalue</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite">noWrite</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_in">noWrite_in</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_insert">noWrite_insert</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_movFront">noWrite_movFront</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_pop">noWrite_pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_swap">noWrite_swap</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_tmpLast">noWrite_tmpLast</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#no_overlap">no_overlap</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#no_overlap">no_overlap</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlapD_inv">no_overlapD_inv</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlapD_invf">no_overlapD_invf</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlapD_invpp">no_overlapD_invpp</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlapD_res">no_overlapD_res</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Conventions.html#no_overlap_arguments">no_overlap_arguments</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Parallelmove.html#no_overlap_list">no_overlap_list</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlap_list_pop">no_overlap_list_pop</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#no_overlap_noOverlap">no_overlap_noOverlap</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Conventions.html#no_overlap_parameters">no_overlap_parameters</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Parallelmove.html#no_overlap_state">no_overlap_state</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlap_stateD">no_overlap_stateD</a> [definition, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlap_temp">no_overlap_temp</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Kildall.html#no_self_loop">no_self_loop</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_tmp13_state">no_tmp13_state</a> [definition, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="lib.Coqlib.html#nth_error_in">nth_error_in</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#nth_error_nil">nth_error_nil</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Mem.html#nullptr">nullptr</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.CSE.html#Numbering">Numbering</a> [module, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#numbering">numbering</a> [inductive, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#numbering_holds">numbering_holds</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#numbering_holds_exten">numbering_holds_exten</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSE.html#numbering_satisfiable">numbering_satisfiable</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Kildall.html#num_iterations">num_iterations</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<br/><br/><a name="global_O"></a><h2>O </h2>
-<a href="backend.Op.html#Oabsf">Oabsf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oabsf">Oabsf</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Oadd">Oadd</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oadd">Oadd</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oaddf">Oaddf</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oaddf">Oaddf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oaddimm">Oaddimm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oaddrstack">Oaddrstack</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oaddrsymbol">Oaddrsymbol</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oand">Oand</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oand">Oand</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oandimm">Oandimm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ocast16signed">Ocast16signed</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ocast16signed">Ocast16signed</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ocast16unsigned">Ocast16unsigned</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ocast8signed">Ocast8signed</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ocast8signed">Ocast8signed</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ocast8unsigned">Ocast8unsigned</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ocmp">Ocmp</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ocmp">Ocmp</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ocmpf">Ocmpf</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ocmpu">Ocmpu</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Odiv">Odiv</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Odiv">Odiv</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Odivf">Odivf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Odivf">Odivf</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Odivu">Odivu</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Odivu">Odivu</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Stacking.html#offset_of_index">offset_of_index</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stackingproof.html#offset_of_index_disj">offset_of_index_disj</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#offset_of_index_no_overflow">offset_of_index_no_overflow</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#offset_of_index_valid">offset_of_index_valid</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Op.html#offset_sp">offset_sp</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ofloatconst">Ofloatconst</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ofloatconst">Ofloatconst</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ofloatofint">Ofloatofint</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ofloatofint">Ofloatofint</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ofloatofintu">Ofloatofintu</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ofloatofintu">Ofloatofintu</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Values.html#of_bool">of_bool</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#of_bool_is_bool">of_bool_is_bool</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Csharpminor.html#Ointconst">Ointconst</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ointconst">Ointconst</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ointoffloat">Ointoffloat</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ointoffloat">Ointoffloat</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.RTLgen.html#OK">OK</a> [constructor, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.PPC.html#OK">OK</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Csharpminor.html#Omod">Omod</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Omodu">Omodu</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Omove">Omove</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Omul">Omul</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Omul">Omul</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Omuladdf">Omuladdf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Omulf">Omulf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Omulf">Omulf</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Omulimm">Omulimm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Omulsubf">Omulsubf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Onand">Onand</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Integers.html#one">one</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Floats.html#one">one</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Csharpminor.html#Onegf">Onegf</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Onegf">Onegf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Integers.html#one_bits">one_bits</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#one_bits_decomp">one_bits_decomp</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#one_bits_range">one_bits_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#one_not_zero">one_not_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Op.html#Onor">Onor</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Onotint">Onotint</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Onxor">Onxor</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oor">Oor</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oor">Oor</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oorimm">Oorimm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.CSE.html#Op">Op</a> [constructor, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Op.html">Op</a> [library]<br/>
-<a href="backend.Csharpminor.html#operation">operation</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#operation">operation</a> [inductive, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.RTLtyping.html#option_fold2">option_fold2</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Coqlib.html#option_map">option_map</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.union_find.html#option_sum">option_sum</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction">op_strength_reduction</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_cases">op_strength_reduction_cases</a> [inductive, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case1">op_strength_reduction_case1</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case10">op_strength_reduction_case10</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case11">op_strength_reduction_case11</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case12">op_strength_reduction_case12</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case2">op_strength_reduction_case2</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case3">op_strength_reduction_case3</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case4">op_strength_reduction_case4</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case5">op_strength_reduction_case5</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case6">op_strength_reduction_case6</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case7">op_strength_reduction_case7</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case8">op_strength_reduction_case8</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case9">op_strength_reduction_case9</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constpropproof.html#op_strength_reduction_correct">op_strength_reduction_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_default">op_strength_reduction_default</a> [constructor, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_match">op_strength_reduction_match</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Integers.html#or">or</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or">or</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#or">or</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Ordered.html">Ordered</a> [library]<br/>
-<a href="lib.Ordered.html#OrderedIndexed">OrderedIndexed</a> [module, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.InterfGraph.html#OrderedMreg">OrderedMreg</a> [module, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="lib.Ordered.html#OrderedPair">OrderedPair</a> [module, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#OrderedPositive">OrderedPositive</a> [module, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.InterfGraph.html#OrderedReg">OrderedReg</a> [module, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#OrderedRegMreg">OrderedRegMreg</a> [module, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#OrderedRegReg">OrderedRegReg</a> [module, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#ordered_pair">ordered_pair</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#ordered_pair_charact">ordered_pair_charact</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#ordered_pair_sym">ordered_pair_sym</a> [lemma, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Kildall.html#ORDERED_TYPE_WITH_TOP">ORDERED_TYPE_WITH_TOP</a> [module, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.PPCgen.html#orimm">orimm</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#orimm_correct">orimm_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Op.html#Orolm">Orolm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Integers.html#or_assoc">or_assoc</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or_assoc">or_assoc</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#or_cases">or_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#or_case1">or_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#or_commut">or_commut</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or_commut">or_commut</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#or_default">or_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#or_idem">or_idem</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#or_match">or_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#or_mone">or_mone</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or_of_bool">or_of_bool</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#or_rolm">or_rolm</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or_rolm">or_rolm</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#or_zero">or_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Csharpminor.html#Oshl">Oshl</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oshl">Oshl</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oshr">Oshr</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oshr">Oshr</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oshrimm">Oshrimm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oshru">Oshru</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oshru">Oshru</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oshrximm">Oshrximm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Osingleoffloat">Osingleoffloat</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Osingleoffloat">Osingleoffloat</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Osub">Osub</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Osub">Osub</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Osubf">Osubf</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Osubf">Osubf</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Osubimm">Osubimm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oundef">Oundef</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cminor.html#outcome">outcome</a> [inductive, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.LTL.html#outcome">outcome</a> [inductive, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.PPC.html#outcome">outcome</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Csharpminor.html#outcome">outcome</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#outcome_block">outcome_block</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#outcome_block">outcome_block</a> [definition, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminorgenproof.html#outcome_inject">outcome_inject</a> [inductive, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#outcome_node">outcome_node</a> [definition, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminor.html#outcome_result_value">outcome_result_value</a> [definition, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#outcome_result_value">outcome_result_value</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Locations.html#Outgoing">Outgoing</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Lineartyping.html#outgoing_slot">outgoing_slot</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#outgoing_slot_bound">outgoing_slot_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Lineartyping.html#outgoing_space">outgoing_space</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Csharpminor.html#Out_exit">Out_exit</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Out_exit">Out_exit</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#Out_normal">Out_normal</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Out_normal">Out_normal</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Out_return">Out_return</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Out_return">Out_return</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Locations.html#overlap">overlap</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#overlap_aux">overlap_aux</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#overlap_aux_false_1">overlap_aux_false_1</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#overlap_aux_true_1">overlap_aux_true_1</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#overlap_aux_true_2">overlap_aux_true_2</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#overlap_not_diff">overlap_not_diff</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Op.html#Oxor">Oxor</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oxor">Oxor</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oxorimm">Oxorimm</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<br/><br/><a name="global_P"></a><h2>P </h2>
-<a href="backend.PPC.html#Padd">Padd</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Paddi">Paddi</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Paddis">Paddis</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Paddze">Paddze</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pallocframe">Pallocframe</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pandc">Pandc</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pandis_">Pandis_</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pandi_">Pandi_</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pand_">Pand_</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Parallelmove.html">Parallelmove</a> [library]<br/>
-<a href="backend.Allocation.html#parallel_move">parallel_move</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#parallel_move_correct">parallel_move_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof_aux.html#parallel_move_correctX">parallel_move_correctX</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#parallel_move_correct'">parallel_move_correct'</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocation.html#parallel_move_order">parallel_move_order</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Conventions.html#parameter_of_argument">parameter_of_argument</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Parallelmove.html#path">path</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#path_pop">path_pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#path_tmpLast">path_tmpLast</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.PPC.html#Pb">Pb</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbctr">Pbctr</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbctrl">Pbctrl</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbf">Pbf</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbl">Pbl</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pblr">Pblr</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbt">Pbt</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#PC">PC</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcmplw">Pcmplw</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcmplwi">Pcmplwi</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcmpw">Pcmpw</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcmpwi">Pcmpwi</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcror">Pcror</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pdivw">Pdivw</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pdivwu">Pdivwu</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Coqlib.html#peq">peq</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.PPC.html#Peqv">Peqv</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Coqlib.html#peq_false">peq_false</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#peq_true">peq_true</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Parallelmove.html#pexec">pexec</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_add">pexec_add</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_correct">pexec_correct</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_mov">pexec_mov</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_movBack">pexec_movBack</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_movFront">pexec_movFront</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_nop">pexec_nop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_push">pexec_push</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_swap">pexec_swap</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_update">pexec_update</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.PPC.html#Pextsb">Pextsb</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pextsh">Pextsh</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfabs">Pfabs</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfadd">Pfadd</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfcmpu">Pfcmpu</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfcti">Pfcti</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfdiv">Pfdiv</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfmadd">Pfmadd</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfmr">Pfmr</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfmsub">Pfmsub</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfmul">Pfmul</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfneg">Pfneg</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfreeframe">Pfreeframe</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfrsp">Pfrsp</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfsub">Pfsub</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfundef">Pfundef</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pictf">Pictf</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Piuctf">Piuctf</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Piundef">Piundef</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plabel">Plabel</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plbz">Plbz</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plbzx">Plbzx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Coqlib.html#Ple">Ple</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Ple_refl">Ple_refl</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Ple_succ">Ple_succ</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Ple_trans">Ple_trans</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.PPC.html#Plfd">Plfd</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plfdx">Plfdx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plfi">Plfi</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plfs">Plfs</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plfsx">Plfsx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plha">Plha</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plhax">Plhax</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plhz">Plhz</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plhzx">Plhzx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Coqlib.html#Plt">Plt</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#plt">plt</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_ne">Plt_ne</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_Ple">Plt_Ple</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_Ple_trans">Plt_Ple_trans</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_strict">Plt_strict</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_succ">Plt_succ</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_succ_inv">Plt_succ_inv</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_trans">Plt_trans</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_trans_succ">Plt_trans_succ</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_wf">Plt_wf</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.PPC.html#Plwz">Plwz</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plwzx">Plwzx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Maps.html#PMap">PMap</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.PPC.html#Pmfcrbit">Pmfcrbit</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmflr">Pmflr</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Parallelmove.html#Pmov">Pmov</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Pmov_equation">Pmov_equation</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.PPC.html#Pmr">Pmr</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmtctr">Pmtctr</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmtlr">Pmtlr</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmulli">Pmulli</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmullw">Pmullw</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pnand">Pnand</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pnor">Pnor</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Por">Por</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Porc">Porc</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pori">Pori</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Poris">Poris</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Coqlib.html#positive_Peano_ind">positive_Peano_ind</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#positive_rec">positive_rec</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#positive_rec_base">positive_rec_base</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#positive_rec_succ">positive_rec_succ</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#powerserie">powerserie</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.PPC.html">PPC</a> [library]<br/>
-<a href="backend.PPCgen.html">PPCgen</a> [library]<br/>
-<a href="backend.PPCgenproof.html">PPCgenproof</a> [library]<br/>
-<a href="backend.PPCgenproof1.html">PPCgenproof1</a> [library]<br/>
-<a href="lib.Coqlib.html#Ppred_Plt">Ppred_Plt</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Kildall.html#predecessors">predecessors</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#predecessors_correct">predecessors_correct</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.PPC.html#preg">preg</a> [inductive, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#PregEq">PregEq</a> [module, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pregmap">Pregmap</a> [module, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#preg_eq">preg_eq</a> [lemma, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of">preg_of</a> [definition, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of_injective">preg_of_injective</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of_is_data_reg">preg_of_is_data_reg</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of_not">preg_of_not</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of_not_GPR1">preg_of_not_GPR1</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_val">preg_val</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPC.html#Prlwinm">Prlwinm</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.LTL.html#program">program</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Cminor.html#program">program</a> [definition, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Linear.html#program">program</a> [definition, in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.AST.html#program">program</a> [inductive, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.RTL.html#program">program</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Csharpminor.html#program">program</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.PPC.html#program">program</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#program">program</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Tunnelingtyping.html#program_typing_preserved">program_typing_preserved</a> [lemma, in <a href="backend.Tunnelingtyping.html">backend.Tunnelingtyping</a>]<br/>
-<a href="backend.Linearizetyping.html#program_typing_preserved">program_typing_preserved</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Alloctyping.html#program_typing_preserved">program_typing_preserved</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#program_typing_preserved">program_typing_preserved</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Globalenvs.html#prog_funct_transf_OK">prog_funct_transf_OK</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="lib.Coqlib.html#proof_irrelevance">proof_irrelevance</a> [axiom, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ">propagate_succ</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors">propagate_successors</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors_charact1">propagate_successors_charact1</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors_charact2">propagate_successors_charact2</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors_invariant">propagate_successors_invariant</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors_P">propagate_successors_P</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_charact">propagate_succ_charact</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_incr">propagate_succ_incr</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_incr_worklist">propagate_succ_incr_worklist</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list">propagate_succ_list</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list_charact">propagate_succ_list_charact</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list_incr">propagate_succ_list_incr</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list_incr_worklist">propagate_succ_list_incr_worklist</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list_records_changes">propagate_succ_list_records_changes</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_records_changes">propagate_succ_records_changes</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.PPC.html#Pslw">Pslw</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psraw">Psraw</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psrawi">Psrawi</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psrw">Psrw</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Kildall.html#Pstate">Pstate</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.PPC.html#Pstb">Pstb</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstbx">Pstbx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstfd">Pstfd</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstfdx">Pstfdx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstfs">Pstfs</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstfsx">Pstfsx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psth">Psth</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psthx">Psthx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstw">Pstw</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstwx">Pstwx</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psubfc">Psubfc</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psubfic">Psubfic</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Maps.html#PTree">PTree</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.PPC.html#Pxor">Pxor</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pxori">Pxori</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pxoris">Pxoris</a> [constructor, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Allocproof_aux.html#p_move">p_move</a> [definition, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#P_move">P_move</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<br/><br/><a name="global_R"></a><h2>R </h2>
-<a href="backend.Locations.html#R">R</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Coloring.html#R">R</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Linearize.html#reachable">reachable</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearize.html#reachable_aux">reachable_aux</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearizeproof.html#reachable_correct_1">reachable_correct_1</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#reachable_correct_2">reachable_correct_2</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#reachable_entrypoint">reachable_entrypoint</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#reachable_successors">reachable_successors</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Parallelmove.html#rebuild_l">rebuild_l</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.CSE.html#refl_ge">refl_ge</a> [lemma, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Registers.html#Reg">Reg</a> [module, in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Registers.html#reg">reg</a> [definition, in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Parallelmove.html#Reg">Reg</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Coloring.html#regalloc">regalloc</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_acceptable">regalloc_acceptable</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_correct_1">regalloc_correct_1</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_correct_2">regalloc_correct_2</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_correct_3">regalloc_correct_3</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_disj_temporaries">regalloc_disj_temporaries</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_norepet_norepet">regalloc_norepet_norepet</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_noteq_diff">regalloc_noteq_diff</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_notin_notin">regalloc_notin_notin</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_not_temporary">regalloc_not_temporary</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_ok">regalloc_ok</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_preserves_types">regalloc_preserves_types</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.RTLtyping.html#regenv">regenv</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Mach.html#RegEq">RegEq</a> [module, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Registers.html">Registers</a> [library]<br/>
-<a href="backend.Conventions.html#register_classification">register_classification</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.LTL.html#reglist">reglist</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Mach.html#Regmap">Regmap</a> [module, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Registers.html#Regmap">Regmap</a> [module, in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Registers.html#regmap_optget">regmap_optget</a> [definition, in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Registers.html#regmap_optset">regmap_optset</a> [definition, in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Coloringproof.html#regsalloc_acceptable">regsalloc_acceptable</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Mach.html#regset">regset</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.RTL.html#regset">regset</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.PPC.html#regset">regset</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Registers.html#Regset">Regset</a> [module, in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Allocation.html#regs_for">regs_for</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#regs_for_rec">regs_for_rec</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Constpropproof.html#regs_match_approx">regs_match_approx</a> [definition, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#regs_match_approx_increasing">regs_match_approx_increasing</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#regs_match_approx_update">regs_match_approx_update</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Lineartyping.html#regs_of_instr">regs_of_instr</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Allocation.html#reg_for">reg_for</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#reg_for_spec">reg_for_spec</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_fresh">reg_fresh</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_fresh_decr">reg_fresh_decr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_in_map">reg_in_map</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_in_map_valid">reg_in_map_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Allocation.html#reg_list_dead">reg_list_dead</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#reg_list_live">reg_list_live</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.PPC.html#reg_of_crbit">reg_of_crbit</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Allocation.html#reg_option_live">reg_option_live</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#reg_sum_live">reg_sum_live</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_valid">reg_valid</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_valid_incr">reg_valid_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.CSE.html#reg_valnum">reg_valnum</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#reg_valnum_correct">reg_valnum_correct</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.Sets.html#remove">remove</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#remove">remove</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Inclusion.html#remove_all_leaves">remove_all_leaves</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#remove_all_leaves_sound">remove_all_leaves_sound</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.RTLtyping.html#repet">repet</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#repet_correct">repet_correct</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#replace_last_id">replace_last_id</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#replace_last_s">replace_last_s</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.union_find.html#repr">repr</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.Integers.html#repr">repr</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.union_find.html#repr_aux">repr_aux</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_aux_canon">repr_aux_canon</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_aux_none">repr_aux_none</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_aux_some">repr_aux_some</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_empty">repr_empty</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_order">repr_order</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_rec">repr_rec</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_rec_ext">repr_rec_ext</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_repr">repr_repr</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.Integers.html#repr_signed">repr_signed</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#repr_unsigned">repr_unsigned</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLgen.html#res">res</a> [inductive, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#reserve_instr">reserve_instr</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#reserve_instr_incr">reserve_instr_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#reserve_instr_wf">reserve_instr_wf</a> [lemma, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Stacking.html#restore_callee_save">restore_callee_save</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stackingproof.html#restore_callee_save_correct">restore_callee_save_correct</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stacking.html#restore_float_callee_save">restore_float_callee_save</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stackingproof.html#restore_float_callee_save_correct">restore_float_callee_save_correct</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#restore_float_callee_save_correct_rec">restore_float_callee_save_correct_rec</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stacking.html#restore_int_callee_save">restore_int_callee_save</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stackingproof.html#restore_int_callee_save_correct">restore_int_callee_save_correct</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#restore_int_callee_save_correct_rec">restore_int_callee_save_correct_rec</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Kildall.html#result">result</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Allocproof_aux.html#reswellFormed">reswellFormed</a> [definition, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.RTLgen.html#ret">ret</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.LTL.html#Return">Return</a> [constructor, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#return_regs">return_regs</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Allocproof.html#return_regs_not_destroyed">return_regs_not_destroyed</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#return_regs_result">return_regs_result</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#return_reg_ok">return_reg_ok</a> [inductive, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#return_reg_ok_incr">return_reg_ok_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#return_reg_ok_none">return_reg_ok_none</a> [constructor, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#return_reg_ok_some">return_reg_ok_some</a> [constructor, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#ret_reg">ret_reg</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.CSE.html#rhs">rhs</a> [inductive, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#rhs_evals_to">rhs_evals_to</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Parallelmove.html#right">right</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Maps.html#rleaf">rleaf</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Integers.html#rlw_accepting">rlw_accepting</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_Sbad">RLW_Sbad</a> [constructor, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rlw_state">rlw_state</a> [inductive, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S0">RLW_S0</a> [constructor, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S1">RLW_S1</a> [constructor, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S2">RLW_S2</a> [constructor, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S3">RLW_S3</a> [constructor, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S4">RLW_S4</a> [constructor, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S5">RLW_S5</a> [constructor, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S6">RLW_S6</a> [constructor, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rlw_transition">rlw_transition</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rol">rol</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#rolm">rolm</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#rolm">rolm</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#rolm">rolm</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_cases">rolm_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_case1">rolm_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_case2">rolm_case2</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_default">rolm_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_match">rolm_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#rolm_rolm">rolm_rolm</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#rolm_rolm">rolm_rolm</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#rolm_zero">rolm_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#rolm_zero">rolm_zero</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#rol_and">rol_and</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rol_or">rol_or</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rol_rol">rol_rol</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rol_zero">rol_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTL.html">RTL</a> [library]<br/>
-<a href="backend.RTLgen.html">RTLgen</a> [library]<br/>
-<a href="backend.RTLgenproof.html">RTLgenproof</a> [library]<br/>
-<a href="backend.RTLgenproof1.html">RTLgenproof1</a> [library]<br/>
-<a href="backend.RTLtyping.html">RTLtyping</a> [library]<br/>
-<a href="backend.Locations.html#R10">R10</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R13">R13</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R14">R14</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R15">R15</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R16">R16</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R17">R17</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R18">R18</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R19">R19</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Op.html#r2">r2</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#r2">r2</a> [constructor, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Locations.html#R20">R20</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R21">R21</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R22">R22</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R23">R23</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R24">R24</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R25">R25</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R26">R26</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R27">R27</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R28">R28</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R29">R29</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R3">R3</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R30">R30</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R31">R31</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R4">R4</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R5">R5</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R6">R6</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R7">R7</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R8">R8</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R9">R9</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<br/><br/><a name="global_S"></a><h2>S </h2>
-<a href="backend.Locations.html#S">S</a> [constructor, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.union_find.html#sameclass">sameclass</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass">sameclass</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_empty">sameclass_empty</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_identify_1">sameclass_identify_1</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_identify_2">sameclass_identify_2</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_refl">sameclass_refl</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_repr">sameclass_repr</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_sym">sameclass_sym</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_trans">sameclass_trans</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.Parallelmove.html#sameEnv">sameEnv</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#sameExec">sameExec</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#sameExec_reflexive">sameExec_reflexive</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#sameExec_transitive">sameExec_transitive</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cmconstr.html#same_expr_pure">same_expr_pure</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Locations.html#same_not_diff">same_not_diff</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Coloring.html#same_typ">same_typ</a> [definition, in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloringproof.html#same_typ_correct">same_typ_correct</a> [lemma, in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Stacking.html#save_callee_save">save_callee_save</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stackingproof.html#save_callee_save_correct">save_callee_save_correct</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stacking.html#save_float_callee_save">save_float_callee_save</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stackingproof.html#save_float_callee_save_correct">save_float_callee_save_correct</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#save_float_callee_save_correct_rec">save_float_callee_save_correct_rec</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stacking.html#save_int_callee_save">save_int_callee_save</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stackingproof.html#save_int_callee_save_correct">save_int_callee_save_correct</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#save_int_callee_save_correct_rec">save_int_callee_save_correct_rec</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Cminor.html#Sblock">Sblock</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Sblock">Sblock</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Parallelmove.html#SB_Pmov">SB_Pmov</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cminor.html#Scons">Scons</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Scons">Scons</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Allocproof_aux.html#SDone_Pmov">SDone_Pmov</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#SDone_stepf">SDone_stepf</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#sD_nW">sD_nW</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#sD_pexec">sD_pexec</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Lattice.html#SEMILATTICE">SEMILATTICE</a> [module, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#SEMILATTICE_WITH_TOP">SEMILATTICE_WITH_TOP</a> [module, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#set">set</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#set">set</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#set">set</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#set">set</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#set">set</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#set">set</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.InterfGraph.html#SetDepRegMreg">SetDepRegMreg</a> [module, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#SetDepRegReg">SetDepRegReg</a> [module, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Mem.html#setN">setN</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#setN_agree">setN_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#setN_inject">setN_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#setN_outside_agree">setN_outside_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#setN_outside_inject">setN_outside_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.InterfGraph.html#SetRegMreg">SetRegMreg</a> [module, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#SetRegReg">SetRegReg</a> [module, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="lib.Sets.html">Sets</a> [library]<br/>
-<a href="backend.Mem.html#set_cont">set_cont</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_agree">set_cont_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_inject">set_cont_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_inside">set_cont_inside</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_outside">set_cont_outside</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_outside1">set_cont_outside1</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_outside_agree">set_cont_outside_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_outside_inject">set_cont_outside_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminor.html#set_locals">set_locals</a> [definition, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminorgenproof.html#set_locals_defined">set_locals_defined</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#set_locals_params_defined">set_locals_params_defined</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminor.html#set_params">set_params</a> [definition, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminorgenproof.html#set_params_defined">set_params_defined</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Machabstr.html#set_slot">set_slot</a> [inductive, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Stackingproof.html#set_slot_index">set_slot_index</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Machabstr.html#set_slot_intro">set_slot_intro</a> [constructor, in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Machtyping.html#set_slot_link_invariant">set_slot_link_invariant</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Stackingproof.html#set_slot_ok">set_slot_ok</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Parallelmove.html#Sexec">Sexec</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#sexec">sexec</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cminor.html#Sexit">Sexit</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Sexit">Sexit</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Sexpr">Sexpr</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Sexpr">Sexpr</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cmconstr.html#shift_cases">shift_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#shift_case1">shift_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#shift_default">shift_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Stackingproof.html#shift_eval_addressing">shift_eval_addressing</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#shift_eval_operation">shift_eval_operation</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Cmconstr.html#shift_match">shift_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Stackingproof.html#shift_sp">shift_sp</a> [definition, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="lib.Integers.html#shl">shl</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#shl">shl</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#shl">shl</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#shlimm">shlimm</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#shl_mul">shl_mul</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shl_mul">shl_mul</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shl_mul_two_p">shl_mul_two_p</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shl_rolm">shl_rolm</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shl_rolm">shl_rolm</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shl_zero">shl_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shr">shr</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#shr">shr</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#shr">shr</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#shru">shru</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#shru">shru</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shru">shru</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#shruimm">shruimm</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#shru_div_two_p">shru_div_two_p</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shru_rolm">shru_rolm</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shru_rolm">shru_rolm</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shru_zero">shru_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shrx">shrx</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shrx">shrx</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#shrx_carry">shrx_carry</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shrx_carry">shrx_carry</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shr_carry">shr_carry</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shr_carry">shr_carry</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shr_zero">shr_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Csharpminor.html#Sifthenelse">Sifthenelse</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Sifthenelse">Sifthenelse</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.AST.html#signature">signature</a> [inductive, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="lib.Integers.html#signed">signed</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#signed_range">signed_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#signed_repr">signed_repr</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Allocproof.html#sig_function_translated">sig_function_translated</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#sig_transl_function">sig_transl_function</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest">simpleDest</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_insert">simpleDest_insert</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_movBack">simpleDest_movBack</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_movFront">simpleDest_movFront</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_Pop">simpleDest_Pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_pop">simpleDest_pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_pop2">simpleDest_pop2</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_right">simpleDest_right</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_swap">simpleDest_swap</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_swap_app">simpleDest_swap_app</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_tmpLast">simpleDest_tmpLast</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Values.html#singleoffloat">singleoffloat</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#singleoffloat">singleoffloat</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Floats.html#singleoffloat">singleoffloat</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#singleoffloat_idem">singleoffloat_idem</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Csharpminor.html#sizeof">sizeof</a> [definition, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Mem.html#Size16">Size16</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Size32">Size32</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Size64">Size64</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Size8">Size8</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Conventions.html#size_arguments">size_arguments</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Linearizetyping.html#size_arguments_bound">size_arguments_bound</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Conventions.html#size_arguments_rec">size_arguments_rec</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Mem.html#size_chunk">size_chunk</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#size_chunk_pos">size_chunk_pos</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#size_mem">size_mem</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#size_mem_pos">size_mem_pos</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Stackingproof.html#size_no_overflow">size_no_overflow</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#size_pos">size_pos</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Csharpminor.html#Sloop">Sloop</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Sloop">Sloop</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Locations.html#slot">slot</a> [inductive, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Lineartyping.html#slots_of_instr">slots_of_instr</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#slot_bounded">slot_bounded</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.LTLtyping.html#slot_bounded">slot_bounded</a> [definition, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.Locations.html#slot_eq">slot_eq</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Stackingproof.html#slot_gi">slot_gi</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#slot_gso">slot_gso</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#slot_gss">slot_gss</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#slot_iso">slot_iso</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#slot_iss">slot_iss</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Linearizetyping.html#slot_is_bounded">slot_is_bounded</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Locations.html#slot_type">slot_type</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Csharpminor.html#Snil">Snil</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Snil">Snil</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.CSE.html#Solver">Solver</a> [module, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Parallelmove.html#Some">Some</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Inclusion.html#sort_bin">sort_bin</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#sort_included">sort_included</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#sort_included2">sort_included2</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Parallelmove.html#splitNone">splitNone</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#splitSome">splitSome</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#split_length">split_length</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#split_move">split_move</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#split_move'">split_move'</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#split_move_incl">split_move_incl</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.PPCgenproof1.html#sp_val">sp_val</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Alloctyping_aux.html#srcdst_tmp2_stepf">srcdst_tmp2_stepf</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Alloctyping_aux.html#src_tmp2_res">src_tmp2_res</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Csharpminor.html#Sreturn">Sreturn</a> [constructor, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Sreturn">Sreturn</a> [constructor, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Stacking.html">Stacking</a> [library]<br/>
-<a href="backend.Stackingproof.html">Stackingproof</a> [library]<br/>
-<a href="backend.Stackingtyping.html">Stackingtyping</a> [library]<br/>
-<a href="backend.Linearize.html#starts_with">starts_with</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearizeproof.html#starts_with_correct">starts_with_correct</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Kildall.html#start_state">start_state</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#start_state_good">start_state_good</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#start_state_in">start_state_in</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#start_state_in_entry">start_state_in_entry</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#start_state_wrk">start_state_wrk</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#state">state</a> [inductive, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#State">State</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLgen.html#state">state</a> [inductive, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Kildall.html#state">state</a> [inductive, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#StateBeing">StateBeing</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#StateDone">StateDone</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#StateToMove">StateToMove</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_extends">state_extends</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr">state_incr</a> [inductive, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_extends">state_incr_extends</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_intro">state_incr_intro</a> [constructor, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_refl">state_incr_refl</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans">state_incr_trans</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans2">state_incr_trans2</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans3">state_incr_trans3</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans4">state_incr_trans4</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans5">state_incr_trans5</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans6">state_incr_trans6</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Kildall.html#state_invariant">state_invariant</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#step">step</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#step">step</a> [inductive, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Kildall.html#step">step</a> [definition, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#stepf">stepf</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf'">stepf'</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf1_dec">stepf1_dec</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_dec">stepf_dec</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_dec0">stepf_dec0</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_dec0'">stepf_dec0'</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_pop">stepf_pop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_popLoop">stepf_popLoop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepInv">stepInv</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#stepInv_pnilnil">stepInv_pnilnil</a> [lemma, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#stepp">stepp</a> [inductive, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_inv">stepp_inv</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_refl">stepp_refl</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_sameExec">stepp_sameExec</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_trans">stepp_trans</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_transitive">stepp_transitive</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLtyping.html#step1">step1</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#step2">step2</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#step3">step3</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#step4">step4</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#step_dec">step_dec</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_dec0">step_dec0</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv">step_inv</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_getdst">step_inv_getdst</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_loop">step_inv_loop</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_loop_aux">step_inv_loop_aux</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_noOverlap">step_inv_noOverlap</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_NoOverlap">step_inv_NoOverlap</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_noTmp">step_inv_noTmp</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_noTmpLast">step_inv_noTmpLast</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_path">step_inv_path</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_simpleDest">step_inv_simpleDest</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_loop">step_loop</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_NF">step_NF</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_nop">step_nop</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_pop">step_pop</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_push">step_push</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_sameExec">step_sameExec</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_start">step_start</a> [constructor, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Kildall.html#step_state_good">step_state_good</a> [lemma, in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#step_stepp">step_stepp</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Csharpminor.html#stmt">stmt</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#stmt">stmt</a> [inductive, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#stmtlist">stmtlist</a> [inductive, in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#stmtlist">stmtlist</a> [inductive, in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.RTLgenproof1.html#stmt_stmtlist_ind">stmt_stmtlist_ind</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Parallelmove.html#STM_Pmov">STM_Pmov</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cmconstr.html#store">store</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Mem.html#store">store</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgen.html#storeind">storeind</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#storeind_aux">storeind_aux</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#storeind_aux_correct">storeind_aux_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#storeind_correct">storeind_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Mem.html#storev">storev</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#storev_mapped_inject">storev_mapped_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#storev_mapped_inject_1">storev_mapped_inject_1</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgenproof.html#storev_16_signed_unsigned">storev_16_signed_unsigned</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#storev_8_signed_unsigned">storev_8_signed_unsigned</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPC.html#store1">store1</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#store2">store2</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mem.html#store_agree">store_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_alloc">store_alloc</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_contentmap_agree">store_contentmap_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_contentmap_outside_agree">store_contentmap_outside_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_contents">store_contents</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_contents_inject">store_contents_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_contents_outside_inject">store_contents_outside_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_inv">store_inv</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_in_bounds">store_in_bounds</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_is_in_bounds">store_is_in_bounds</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_mapped_inject">store_mapped_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_mapped_inject_1">store_mapped_inject_1</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_outside_agree">store_outside_agree</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_outside_extends">store_outside_extends</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgen.html#store_parameters">store_parameters</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#store_parameters_correct">store_parameters_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mach.html#store_stack">store_stack</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mem.html#store_unmapped_inject">store_unmapped_inject</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_within_extends">store_within_extends</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Floats.html#sub">sub</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Values.html#sub">sub</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#sub">sub</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#sub">sub</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#subf">subf</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#subf">subf</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Floats.html#subf_addf_opp">subf_addf_opp</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="backend.Cmconstr.html#subf_cases">subf_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#subf_case1">subf_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#subf_default">subf_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#subf_match">subf_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Machtyping.html#subject_reduction">subject_reduction</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#subject_reduction">subject_reduction</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Machtyping.html#subject_reduction_function">subject_reduction_function</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#subject_reduction_instr">subject_reduction_instr</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#subject_reduction_instrs">subject_reduction_instrs</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Values.html#sub_add_l">sub_add_l</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#sub_add_l">sub_add_l</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#sub_add_opp">sub_add_opp</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#sub_add_opp">sub_add_opp</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#sub_add_r">sub_add_r</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#sub_add_r">sub_add_r</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#sub_cases">sub_cases</a> [inductive, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_case1">sub_case1</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_case2">sub_case2</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_case3">sub_case3</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_case4">sub_case4</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_default">sub_default</a> [constructor, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#sub_idem">sub_idem</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#sub_match">sub_match</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_match_aux">sub_match_aux</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#sub_shifted">sub_shifted</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#sub_zero_l">sub_zero_l</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#sub_zero_r">sub_zero_r</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#sub_zero_r">sub_zero_r</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.LTL.html#successors">successors</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.RTL.html#successors">successors</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.LTL.html#successors_aux">successors_aux</a> [definition, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#successors_aux_invariant">successors_aux_invariant</a> [lemma, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#successors_correct">successors_correct</a> [lemma, in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.RTL.html#successors_correct">successors_correct</a> [lemma, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="lib.Coqlib.html#sum_left_map">sum_left_map</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#swap_cmp">swap_cmp</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#swap_cmp">swap_cmp</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#swap_cmpu">swap_cmpu</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#swap_cmpu">swap_cmpu</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#swap_cmp_mismatch">swap_cmp_mismatch</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.AST.html#swap_comparison">swap_comparison</a> [definition, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Globalenvs.html#symbols_add_globals_transf">symbols_add_globals_transf</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#symbols_init_transf">symbols_init_transf</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Tunnelingproof.html#symbols_preserved">symbols_preserved</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Allocproof.html#symbols_preserved">symbols_preserved</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#symbols_preserved">symbols_preserved</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Constpropproof.html#symbols_preserved">symbols_preserved</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.PPCgenproof.html#symbols_preserved">symbols_preserved</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#symbols_preserved">symbols_preserved</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Linearizeproof.html#symbols_preserved">symbols_preserved</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.CSEproof.html#symbols_preserved">symbols_preserved</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Stackingproof.html#symbols_preserved">symbols_preserved</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPC.html#symbol_offset">symbol_offset</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Linearize.html#s1">s1</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<br/><br/><a name="global_T"></a><h2>T </h2>
-<a href="backend.PPC.html#t">t</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Ordered.html#t">t</a> [definition, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#t">t</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Locations.html#t">t</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Constprop.html#t">t</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Ordered.html#t">t</a> [definition, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.Globalenvs.html#t">t</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="lib.Lattice.html#t">t</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.RTLtyping.html#T">T</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.union_find.html#T">T</a> [definition, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.CSEproof.html#t">t</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Locations.html#t">t</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Parallelmove.html#T">T</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTLtyping.html#T">T</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.InterfGraph.html#t">t</a> [definition, in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Ordered.html#t">t</a> [definition, in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Lattice.html#t">t</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Mach.html#t">t</a> [definition, in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="lib.Sets.html#t">t</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.CSE.html#t">t</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_regs_cons">target_regs_cons</a> [constructor, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_regs_nil">target_regs_nil</a> [constructor, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_regs_not_mutated">target_regs_not_mutated</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_regs_ok">target_regs_ok</a> [inductive, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_regs_ok_incr">target_regs_ok_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_regs_valid">target_regs_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_immut_var">target_reg_immut_var</a> [constructor, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_not_mutated">target_reg_not_mutated</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_ok">target_reg_ok</a> [inductive, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_ok_incr">target_reg_ok_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_valid">target_reg_valid</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Conventions.html#temporaries">temporaries</a> [definition, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Allocproof_aux.html#temporaries1">temporaries1</a> [definition, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#temporaries1_3">temporaries1_3</a> [definition, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#temporaries2">temporaries2</a> [definition, in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Conventions.html#temporaries_not_acceptable">temporaries_not_acceptable</a> [lemma, in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.RTLtyping.html#teq">teq</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#teq_correct">teq_correct</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Inclusion.html#test_inclusion">test_inclusion</a> [definition, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#test_inclusion_sound">test_inclusion_sound</a> [lemma, in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.AST.html#Tfloat">Tfloat</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Allocation.html#Tint">Tint</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.AST.html#Tint">Tint</a> [constructor, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="lib.Lattice.html#top">top</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#top">top</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.CSE.html#top">top</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Constprop.html#top">top</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#top">top</a> [definition, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.CSE.html#top_ge">top_ge</a> [lemma, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Allocation.html#transfer">transfer</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Constprop.html#transfer">transfer</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.CSE.html#transfer">transfer</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Constpropproof.html#transfer_correct">transfer_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.CSEproof.html#transfer_correct">transfer_correct</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.AST.html#transform_partial_program">transform_partial_program</a> [definition, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Main.html#transform_partial_program_compose">transform_partial_program_compose</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.AST.html#transform_partial_program_function">transform_partial_program_function</a> [lemma, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#transform_partial_program_main">transform_partial_program_main</a> [lemma, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#transform_program">transform_program</a> [definition, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#transform_program_function">transform_program_function</a> [lemma, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Main.html#transform_program_partial_total">transform_program_partial_total</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Globalenvs.html#transform_program_transform_partial_program">transform_program_transform_partial_program</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Main.html#transf_cminor_function">transf_cminor_function</a> [definition, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program">transf_cminor_program</a> [definition, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program2">transf_cminor_program2</a> [definition, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program2_correct">transf_cminor_program2_correct</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program_correct">transf_cminor_program_correct</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program_equiv">transf_cminor_program_equiv</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Constprop.html#transf_code">transf_code</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.CSE.html#transf_code">transf_code</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#transf_code_wf">transf_code_wf</a> [lemma, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Constprop.html#transf_code_wf">transf_code_wf</a> [lemma, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.RTL.html#transf_code_wf">transf_code_wf</a> [lemma, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_function">transf_csharpminor_function</a> [definition, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program">transf_csharpminor_program</a> [definition, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program2">transf_csharpminor_program2</a> [definition, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program2_correct">transf_csharpminor_program2_correct</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program_correct">transf_csharpminor_program_correct</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program_equiv">transf_csharpminor_program_equiv</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Allocation.html#transf_entrypoint">transf_entrypoint</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocproof.html#transf_entrypoint_correct">transf_entrypoint_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocation.html#transf_entrypoint_wf">transf_entrypoint_wf</a> [lemma, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Linearize.html#transf_function">transf_function</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Allocation.html#transf_function">transf_function</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.CSE.html#transf_function">transf_function</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.RTL.html#transf_function">transf_function</a> [definition, in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.PPCgen.html#transf_function">transf_function</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Stacking.html#transf_function">transf_function</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Constprop.html#transf_function">transf_function</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Linearizeproof.html#transf_function_correct">transf_function_correct</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.PPCgenproof.html#transf_function_correct">transf_function_correct</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#transf_function_correct">transf_function_correct</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.CSEproof.html#transf_function_correct">transf_function_correct</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Constpropproof.html#transf_funct_correct">transf_funct_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Allocation.html#transf_instr">transf_instr</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Constprop.html#transf_instr">transf_instr</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.CSE.html#transf_instr">transf_instr</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Globalenvs.html#transf_partial">transf_partial</a> [definition, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.AST.html#transf_partial_program">transf_partial_program</a> [definition, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Main.html#transf_partial_program_compose">transf_partial_program_compose</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.CSE.html#transf_program">transf_program</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.PPCgen.html#transf_program">transf_program</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Stacking.html#transf_program">transf_program</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Constprop.html#transf_program">transf_program</a> [definition, in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Allocation.html#transf_program">transf_program</a> [definition, in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Linearize.html#transf_program">transf_program</a> [definition, in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.AST.html#transf_program">transf_program</a> [definition, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Linearizeproof.html#transf_program_correct">transf_program_correct</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#transf_program_correct">transf_program_correct</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Constpropproof.html#transf_program_correct">transf_program_correct</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.PPCgenproof.html#transf_program_correct">transf_program_correct</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.CSEproof.html#transf_program_correct">transf_program_correct</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Main.html#transf_program_partial_total">transf_program_partial_total</a> [lemma, in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Globalenvs.html#transf_program_transf_partial_program">transf_program_transf_partial_program</a> [lemma, in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="lib.Integers.html#translate_cmp">translate_cmp</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#translate_eq">translate_eq</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#translate_lt">translate_lt</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Stacking.html#transl_addr">transl_addr</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#transl_body">transl_body</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.PPCgen.html#transl_code">transl_code</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Stacking.html#transl_code">transl_code</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.PPCgenproof.html#transl_code_at_pc">transl_code_at_pc</a> [inductive, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#transl_code_label">transl_code_label</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgen.html#transl_cond">transl_cond</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_CEcondition_correct">transl_condition_CEcondition_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_CEcond_correct">transl_condition_CEcond_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_CEfalse_correct">transl_condition_CEfalse_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_CEtrue_correct">transl_condition_CEtrue_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_correct">transl_condition_correct</a> [definition, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_condition_incr">transl_condition_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_condition_incr_pred">transl_condition_incr_pred</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_cond_correct">transl_cond_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_cond_correct_aux">transl_cond_correct_aux</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#transl_expr">transl_expr</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Cminorgen.html#transl_expr">transl_expr</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_exprlist_correct">transl_exprlist_correct</a> [definition, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_exprlist_Econs_correct">transl_exprlist_Econs_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_exprlist_Econs_correct">transl_exprlist_Econs_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_exprlist_Enil_correct">transl_exprlist_Enil_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_exprlist_Enil_correct">transl_exprlist_Enil_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_exprlist_incr">transl_exprlist_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_exprlist_incr_pred">transl_exprlist_incr_pred</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_expr_condition_exprlist_incr">transl_expr_condition_exprlist_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_correct">transl_expr_correct</a> [definition, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eaddrof_global_correct">transl_expr_Eaddrof_global_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eaddrof_local_correct">transl_expr_Eaddrof_local_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eassign_correct">transl_expr_Eassign_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Eassign_correct">transl_expr_Eassign_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Ecall_correct">transl_expr_Ecall_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Ecall_correct">transl_expr_Ecall_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Econdition_correct">transl_expr_Econdition_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Econdition_false_correct">transl_expr_Econdition_false_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Econdition_true_correct">transl_expr_Econdition_true_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Eletvar_correct">transl_expr_Eletvar_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eletvar_correct">transl_expr_Eletvar_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Elet_correct">transl_expr_Elet_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Elet_correct">transl_expr_Elet_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Eload_correct">transl_expr_Eload_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eload_correct">transl_expr_Eload_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Eop_correct">transl_expr_Eop_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eop_correct">transl_expr_Eop_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Estore_correct">transl_expr_Estore_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Estore_correct">transl_expr_Estore_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Evar_correct">transl_expr_Evar_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Evar_correct">transl_expr_Evar_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_expr_incr">transl_expr_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_expr_incr_pred">transl_expr_incr_pred</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof.html#transl_find_label">transl_find_label</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#transl_find_label">transl_find_label</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.RTLgen.html#transl_fun">transl_fun</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_funcall_correct">transl_funcall_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_funcall_correct">transl_funcall_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgen.html#transl_function">transl_function</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.PPCgen.html#transl_function">transl_function</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.RTLgen.html#transl_function">transl_function</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_function_correct">transl_function_correct</a> [definition, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_function_correct">transl_function_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_function_correct">transl_function_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_function_correctness">transl_function_correctness</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_function_correctness">transl_function_correctness</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Icall_correct">transl_Icall_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Icond_false_correct">transl_Icond_false_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Icond_true_correct">transl_Icond_true_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Iload_correct">transl_Iload_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Inop_correct">transl_Inop_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgen.html#transl_instr">transl_instr</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Stacking.html#transl_instr">transl_instr</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.PPCgenproof.html#transl_instr_label">transl_instr_label</a> [lemma, in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Iop_correct">transl_Iop_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Istore_correct">transl_Istore_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_load_correct">transl_load_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgen.html#transl_load_store">transl_load_store</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_load_store_correct">transl_load_store_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#transl_one_correct">transl_one_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Stacking.html#transl_op">transl_op</a> [definition, in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.PPCgen.html#transl_op">transl_op</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_op_correct">transl_op_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#transl_program">transl_program</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Cminorgen.html#transl_program">transl_program</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_program_correct">transl_program_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#transl_program_correct">transl_program_correct</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_program_correct">transl_program_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_program_correct">transl_program_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_refl_correct">transl_refl_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cminorgen.html#transl_stmt">transl_stmt</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.RTLgen.html#transl_stmt">transl_stmt</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmtlist_correct">transl_stmtlist_correct</a> [definition, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmtlist_incr">transl_stmtlist_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmtlist_incr_pred">transl_stmtlist_incr_pred</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmtlist_Scons_continue_correct">transl_stmtlist_Scons_continue_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmtlist_Scons_stop_correct">transl_stmtlist_Scons_stop_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmtlist_Scons_1_correct">transl_stmtlist_Scons_1_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmtlist_Scons_2_correct">transl_stmtlist_Scons_2_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmtlist_Snil_correct">transl_stmtlist_Snil_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmtlist_Snil_correct">transl_stmtlist_Snil_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_correct">transl_stmt_correct</a> [definition, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmt_incr">transl_stmt_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmt_incr_pred">transl_stmt_incr_pred</a> [definition, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sblock_correct">transl_stmt_Sblock_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sblock_correct">transl_stmt_Sblock_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sexit_correct">transl_stmt_Sexit_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sexit_correct">transl_stmt_Sexit_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sexpr_correct">transl_stmt_Sexpr_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sexpr_correct">transl_stmt_Sexpr_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sifthenelse_correct">transl_stmt_Sifthenelse_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sifthenelse_false_correct">transl_stmt_Sifthenelse_false_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sifthenelse_true_correct">transl_stmt_Sifthenelse_true_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sloop_exit_correct">transl_stmt_Sloop_exit_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sloop_loop_correct">transl_stmt_Sloop_loop_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sloop_loop_correct">transl_stmt_Sloop_loop_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sloop_stop_correct">transl_stmt_Sloop_stop_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sreturn_none_correct">transl_stmt_Sreturn_none_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sreturn_none_correct">transl_stmt_Sreturn_none_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sreturn_some_correct">transl_stmt_Sreturn_some_correct</a> [lemma, in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sreturn_some_correct">transl_stmt_Sreturn_some_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmt_stmtlist_incr">transl_stmt_stmtlist_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_store_correct">transl_store_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#transl_trans_correct">transl_trans_correct</a> [lemma, in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="lib.Maps.html#tree">tree</a> [inductive, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#TREE">TREE</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTLtyping.html#tReg">tReg</a> [constructor, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#tTy">tTy</a> [constructor, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Tunnelingproof.html#tunneled_code">tunneled_code</a> [definition, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Tunneling.html">Tunneling</a> [library]<br/>
-<a href="backend.Tunnelingproof.html">Tunnelingproof</a> [library]<br/>
-<a href="backend.Tunnelingtyping.html">Tunnelingtyping</a> [library]<br/>
-<a href="backend.Tunneling.html#tunnel_block">tunnel_block</a> [definition, in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Tunneling.html#tunnel_function">tunnel_function</a> [definition, in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Tunnelingproof.html#tunnel_function_correct">tunnel_function_correct</a> [lemma, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#tunnel_outcome">tunnel_outcome</a> [definition, in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Tunneling.html#tunnel_program">tunnel_program</a> [definition, in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="lib.Coqlib.html#two_power_nat_O">two_power_nat_O</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#two_power_nat_pos">two_power_nat_pos</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.AST.html#typ">typ</a> [inductive, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Locations.html#type">type</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Registers.html#typenv">typenv</a> [definition, in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.AST.html#typesize">typesize</a> [definition, in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Locations.html#typesize">typesize</a> [definition, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#typesize_pos">typesize_pos</a> [lemma, in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_complete">type_args_complete</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_correct">type_args_correct</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_extends">type_args_extends</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_included">type_args_included</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_mapped">type_args_mapped</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_res_complete">type_args_res_complete</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_res_included">type_args_res_included</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_res_ros_included">type_args_res_ros_included</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_complete">type_arg_complete</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_correct">type_arg_correct</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_correct_1">type_arg_correct_1</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_extends">type_arg_extends</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_included">type_arg_included</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_mapped">type_arg_mapped</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_instrs_extends">type_instrs_extends</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_instrs_included">type_instrs_included</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_instr_included">type_instr_included</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Op.html#type_of_addressing">type_of_addressing</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#type_of_chunk">type_of_chunk</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#type_of_chunk_correct">type_of_chunk_correct</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#type_of_condition">type_of_condition</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Stackingproof.html#type_of_index">type_of_index</a> [definition, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Op.html#type_of_operation">type_of_operation</a> [definition, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#type_of_operation_sound">type_of_operation_sound</a> [lemma, in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.RTLtyping.html#type_of_sig_res">type_of_sig_res</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_res_complete">type_res_complete</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_res_correct">type_res_correct</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_ros_complete">type_ros_complete</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_ros_correct">type_ros_correct</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_arg">type_rtl_arg</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function">type_rtl_function</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function_correct">type_rtl_function_correct</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function_instrs">type_rtl_function_instrs</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function_norepet">type_rtl_function_norepet</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function_params">type_rtl_function_params</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_instr">type_rtl_instr</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_ros">type_rtl_ros</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Lattice.html#t_">t_</a> [inductive, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#t_">t_</a> [inductive, in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Alloctyping_aux.html#T_type">T_type</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<br/><br/><a name="global_U"></a><h2>U </h2>
-<a href="backend.RTLtyping.html#Uf">Uf</a> [module, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Mem.html#unchecked_store">unchecked_store</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Undef">Undef</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Values.html#undef_is_bool">undef_is_bool</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Stackingproof.html#unfold_transf_function">unfold_transf_function</a> [lemma, in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="lib.Sets.html#union">union</a> [definition, in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.union_find.html#UNIONFIND">UNIONFIND</a> [module, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#unionfind">unionfind</a> [inductive, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#Unionfind">Unionfind</a> [module, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html">union_find</a> [library]<br/>
-<a href="backend.Linearizeproof.html#unique_labels">unique_labels</a> [definition, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#unique_labels_lin_block">unique_labels_lin_block</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#unique_labels_lin_function">unique_labels_lin_function</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#unique_labels_lin_rec">unique_labels_lin_rec</a> [lemma, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="lib.Coqlib.html#unroll_positive_rec">unroll_positive_rec</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#unsigned">unsigned</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#unsigned_range">unsigned_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#unsigned_range_2">unsigned_range_2</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#unsigned_repr">unsigned_repr</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Parallelmove.html#unsplit_move">unsplit_move</a> [lemma, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Mem.html#update">update</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Parallelmove.html#update">update</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLgen.html#update_instr">update_instr</a> [definition, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#update_instr_extends">update_instr_extends</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#update_instr_incr">update_instr_incr</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#update_instr_wf">update_instr_wf</a> [lemma, in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Mem.html#update_o">update_o</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#update_s">update_s</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<br/><br/><a name="global_V"></a><h2>V </h2>
-<a href="backend.Values.html#Val">Val</a> [module, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#val">val</a> [inductive, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Mem.html#valid_block">valid_block</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#valid_block_alloc">valid_block_alloc</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#valid_block_free">valid_block_free</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#valid_block_store">valid_block_store</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.RTLgenproof1.html#valid_fresh_absurd">valid_fresh_absurd</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#valid_fresh_different">valid_fresh_different</a> [lemma, in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Mem.html#valid_new_block">valid_new_block</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#valid_not_valid_diff">valid_not_valid_diff</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Linearizeproof.html#valid_outcome">valid_outcome</a> [definition, in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Mem.html#valid_pointer">valid_pointer</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#valid_pointer_inject_no_overflow">valid_pointer_inject_no_overflow</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.CSE.html#valnum">valnum</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#ValnumEq">ValnumEq</a> [module, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSE.html#valnum_reg">valnum_reg</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#valnum_regs">valnum_regs</a> [definition, in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSEproof.html#valnum_regs_holds">valnum_regs_holds</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#valnum_reg_holds">valnum_reg_holds</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Parallelmove.html#Value">Value</a> [definition, in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Values.html">Values</a> [library]<br/>
-<a href="backend.CSEproof.html#valu_agree">valu_agree</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#valu_agree_list">valu_agree_list</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#valu_agree_refl">valu_agree_refl</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#valu_agree_trans">valu_agree_trans</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.PPC.html#val_cond_reg">val_cond_reg</a> [definition, in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mem.html#val_cons_inject">val_cons_inject</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_content_inject">val_content_inject</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_content_inject_base">val_content_inject_base</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#val_content_inject_cast">val_content_inject_cast</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#val_content_inject_incr">val_content_inject_incr</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_content_inject_8">val_content_inject_8</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject">val_inject</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject_float">val_inject_float</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject_incr">val_inject_incr</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject_int">val_inject_int</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject_ptr">val_inject_ptr</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_list_inject">val_list_inject</a> [inductive, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_list_inject_incr">val_list_inject_incr</a> [lemma, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Constpropproof.html#val_list_match_approx">val_list_match_approx</a> [inductive, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#val_match_approx">val_match_approx</a> [definition, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#val_match_approx_increasing">val_match_approx_increasing</a> [lemma, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Mem.html#val_nil_inject">val_nil_inject</a> [constructor, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#val_normalized">val_normalized</a> [definition, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_cons">vars_vals_cons</a> [constructor, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_match">vars_vals_match</a> [inductive, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_match_extensional">vars_vals_match_extensional</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_match_holds">vars_vals_match_holds</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_match_holds_1">vars_vals_match_holds_1</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_nil">vars_vals_nil</a> [constructor, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgen.html#var_addr">var_addr</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#var_addr_global_correct">var_addr_global_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#var_addr_local_correct">var_addr_local_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgen.html#var_get">var_get</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#var_get_correct">var_get_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgen.html#Var_global">Var_global</a> [constructor, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#var_info">var_info</a> [inductive, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#Var_local">Var_local</a> [constructor, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#var_set">var_set</a> [definition, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgenproof.html#var_set_correct">var_set_correct</a> [lemma, in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgen.html#Var_stack_array">Var_stack_array</a> [constructor, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#Var_stack_scalar">Var_stack_scalar</a> [constructor, in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Values.html#Vfalse">Vfalse</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vfloat">Vfloat</a> [constructor, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vint">Vint</a> [constructor, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Constpropproof.html#vlma_cons">vlma_cons</a> [constructor, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#vlma_nil">vlma_nil</a> [constructor, in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.CSEproof.html#VMap">VMap</a> [module, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Values.html#Vmone">Vmone</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vone">Vone</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vptr">Vptr</a> [constructor, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vtrue">Vtrue</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vundef">Vundef</a> [constructor, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vzero">Vzero</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<br/><br/><a name="global_W"></a><h2>W </h2>
-<a href="backend.CSEproof.html#wf_add_load">wf_add_load</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_add_op">wf_add_op</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_add_rhs">wf_add_rhs</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_analyze">wf_analyze</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.union_find.html#wf_empty">wf_empty</a> [lemma, in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.CSEproof.html#wf_empty_numbering">wf_empty_numbering</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_equation">wf_equation</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_equation_increasing">wf_equation_increasing</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_kill_loads">wf_kill_loads</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_numbering">wf_numbering</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_rhs">wf_rhs</a> [definition, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_rhs_increasing">wf_rhs_increasing</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_transfer">wf_transfer</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Tunneling.html#wf_tunneled_code">wf_tunneled_code</a> [lemma, in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.CSEproof.html#wf_valnum_reg">wf_valnum_reg</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_valnum_regs">wf_valnum_regs</a> [lemma, in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.Integers.html#wordsize">wordsize</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_call">wt_add_call</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_cond">wt_add_cond</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_entry">wt_add_entry</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_load">wt_add_load</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_move">wt_add_move</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping_aux.html#wt_add_moves">wt_add_moves</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_op_move">wt_add_op_move</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_op_others">wt_add_op_others</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_op_undef">wt_add_op_undef</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_reload">wt_add_reload</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_reloads">wt_add_reloads</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_return">wt_add_return</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_spill">wt_add_spill</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_store">wt_add_store</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_undefs">wt_add_undefs</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_Bgetstack">wt_Bgetstack</a> [constructor, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_block">wt_block</a> [inductive, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_Bop">wt_Bop</a> [constructor, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_Bopmove">wt_Bopmove</a> [constructor, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_Bopundef">wt_Bopundef</a> [constructor, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_Bsetstack">wt_Bsetstack</a> [constructor, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_content">wt_content</a> [definition, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_fold_right">wt_fold_right</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_frame">wt_frame</a> [definition, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_function">wt_function</a> [inductive, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_function">wt_function</a> [inductive, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_function">wt_function</a> [definition, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_function">wt_function</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_get_slot">wt_get_slot</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_init_frame">wt_init_frame</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_init_regs">wt_init_regs</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_Inop">wt_Inop</a> [constructor, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_instr">wt_instr</a> [inductive, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_instr">wt_instr</a> [inductive, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_instr">wt_instr</a> [inductive, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_instrs">wt_instrs</a> [definition, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_instrs_cons">wt_instrs_cons</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_Iop">wt_Iop</a> [constructor, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_Iopmove">wt_Iopmove</a> [constructor, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_Iopundef">wt_Iopundef</a> [constructor, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lgetstack">wt_Lgetstack</a> [constructor, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#wt_linearize_block">wt_linearize_block</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizetyping.html#wt_linearize_body">wt_linearize_body</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lop">wt_Lop</a> [constructor, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lopmove">wt_Lopmove</a> [constructor, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lopundef">wt_Lopundef</a> [constructor, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lsetstack">wt_Lsetstack</a> [constructor, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_Mgetstack">wt_Mgetstack</a> [constructor, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_Mlabel">wt_Mlabel</a> [constructor, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_Msetstack">wt_Msetstack</a> [constructor, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_Msetstack'">wt_Msetstack'</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_parallel_move">wt_parallel_move</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping_aux.html#wt_parallel_moveX">wt_parallel_moveX</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Alloctyping_aux.html#wt_parallel_move'">wt_parallel_move'</a> [lemma, in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Lineartyping.html#wt_program">wt_program</a> [definition, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_program">wt_program</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_program">wt_program</a> [definition, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_program">wt_program</a> [definition, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_regset">wt_regset</a> [definition, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_regset">wt_regset</a> [definition, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_regset_assign">wt_regset_assign</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_regset_list">wt_regset_list</a> [lemma, in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_regs_for">wt_regs_for</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_regs_for_rec">wt_regs_for_rec</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_reg_for">wt_reg_for</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_restore_callee_save">wt_restore_callee_save</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_restore_float_callee_save">wt_restore_float_callee_save</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_restore_int_callee_save">wt_restore_int_callee_save</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_rtl_function">wt_rtl_function</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_save_callee_save">wt_save_callee_save</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_save_float_callee_save">wt_save_float_callee_save</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_save_int_callee_save">wt_save_int_callee_save</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_setreg">wt_setreg</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_set_slot">wt_set_slot</a> [lemma, in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_transf_entrypoint">wt_transf_entrypoint</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_transf_function">wt_transf_function</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_transf_function">wt_transf_function</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Linearizetyping.html#wt_transf_function">wt_transf_function</a> [lemma, in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_transf_instr">wt_transf_instr</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_transf_instrs">wt_transf_instrs</a> [lemma, in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_transl_instr">wt_transl_instr</a> [lemma, in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Tunnelingtyping.html#wt_tunnel_block">wt_tunnel_block</a> [lemma, in <a href="backend.Tunnelingtyping.html">backend.Tunnelingtyping</a>]<br/>
-<a href="backend.Tunnelingtyping.html#wt_tunnel_function">wt_tunnel_function</a> [lemma, in <a href="backend.Tunnelingtyping.html">backend.Tunnelingtyping</a>]<br/>
-<br/><br/><a name="global_X"></a><h2>X </h2>
-<a href="lib.Maps.html#xcombine_l">xcombine_l</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xcombine_lr">xcombine_lr</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xcombine_r">xcombine_r</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements">xelements</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_complete">xelements_complete</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_correct">xelements_correct</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_hi">xelements_hi</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_ho">xelements_ho</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_ih">xelements_ih</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_ii">xelements_ii</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_io">xelements_io</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_keys_norepet">xelements_keys_norepet</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_oh">xelements_oh</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_oi">xelements_oi</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_oo">xelements_oo</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xgcombine">xgcombine</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xgcombine_l">xgcombine_l</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xgcombine_r">xgcombine_r</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xget">xget</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xget_left">xget_left</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xgmap">xgmap</a> [lemma, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xkeys">xkeys</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xmap">xmap</a> [definition, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Cmconstr.html#xor">xor</a> [definition, in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#xor">xor</a> [definition, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#xor">xor</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.PPCgen.html#xorimm">xorimm</a> [definition, in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof1.html#xorimm_correct">xorimm_correct</a> [lemma, in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="lib.Integers.html#xor_assoc">xor_assoc</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#xor_assoc">xor_assoc</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#xor_commut">xor_commut</a> [lemma, in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#xor_commut">xor_commut</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#xor_one_one">xor_one_one</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#xor_zero">xor_zero</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#xor_zero_one">xor_zero_one</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<br/><br/><a name="global_Z"></a><h2>Z </h2>
-<a href="lib.Integers.html#Zdiv_round">Zdiv_round</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Coqlib.html#Zdiv_small">Zdiv_small</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zdiv_unique">Zdiv_unique</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zeq">zeq</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zeq_false">zeq_false</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zeq_true">zeq_true</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#zero">zero</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Floats.html#zero">zero</a> [axiom, in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Maps.html#ZIndexed">ZIndexed</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Coqlib.html#zle">zle</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zle_false">zle_false</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zle_true">zle_true</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zlt">zlt</a> [definition, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zlt_false">zlt_false</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zlt_true">zlt_true</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Maps.html#ZMap">ZMap</a> [module, in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Coqlib.html#Zmax_bound_l">Zmax_bound_l</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmax_bound_r">Zmax_bound_r</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmax_spec">Zmax_spec</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmin_spec">Zmin_spec</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#Zmod_round">Zmod_round</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Coqlib.html#Zmod_small">Zmod_small</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmod_unique">Zmod_unique</a> [lemma, in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Mem.html#ztonat">ztonat</a> [definition, in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Integers.html#Z_bin_decomp">Z_bin_decomp</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_bin_decomp_range">Z_bin_decomp_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_bin_decomp_shift_add">Z_bin_decomp_shift_add</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits">Z_of_bits</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_excl">Z_of_bits_excl</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_exten">Z_of_bits_exten</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_of_Z">Z_of_bits_of_Z</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_range">Z_of_bits_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_range_2">Z_of_bits_range_2</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_shift">Z_of_bits_shift</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_shifts">Z_of_bits_shifts</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_shifts_rev">Z_of_bits_shifts_rev</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_shift_rev">Z_of_bits_shift_rev</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_one_bits">Z_one_bits</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_one_bits_powerserie">Z_one_bits_powerserie</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_one_bits_range">Z_one_bits_range</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_shift_add">Z_shift_add</a> [definition, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_shift_add_bin_decomp">Z_shift_add_bin_decomp</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_shift_add_inj">Z_shift_add_inj</a> [lemma, in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<br/><br/><a name="global__"></a><h2>_ </h2>
-<a href="backend.Lineartyping.html#_">_</a> [constructor, in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.LTLtyping.html#_">_</a> [constructor, in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<br/><br/><hr/>
-<h1>Axiom Index</h1>
-<a name="axiom_A"></a><h2>A </h2>
-<a href="lib.Floats.html#abs">abs</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#add">add</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#addf_commut">addf_commut</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><a name="axiom_C"></a><h2>C </h2>
-<a href="lib.Floats.html#cmp">cmp</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#cmp_ge_gt_eq">cmp_ge_gt_eq</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#cmp_le_lt_eq">cmp_le_lt_eq</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#cmp_ne_eq">cmp_ne_eq</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><a name="axiom_D"></a><h2>D </h2>
-<a href="lib.Floats.html#div">div</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><a name="axiom_E"></a><h2>E </h2>
-<a href="lib.Floats.html#eq_dec">eq_dec</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#eq_zero_false">eq_zero_false</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#eq_zero_true">eq_zero_true</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Coqlib.html#extensionality">extensionality</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<br/><br/><a name="axiom_F"></a><h2>F </h2>
-<a href="lib.Floats.html#float">float</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#floatofint">floatofint</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#floatofintu">floatofintu</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><a name="axiom_G"></a><h2>G </h2>
-<a href="backend.Coloring.html#graph_coloring">graph_coloring</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<br/><br/><a name="axiom_H"></a><h2>H </h2>
-<a href="backend.PPC.html#high_half_signed">high_half_signed</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#high_half_signed_type">high_half_signed_type</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#high_half_unsigned">high_half_unsigned</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#high_half_unsigned_type">high_half_unsigned_type</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<br/><br/><a name="axiom_I"></a><h2>I </h2>
-<a href="lib.Floats.html#intoffloat">intoffloat</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><a name="axiom_L"></a><h2>L </h2>
-<a href="backend.PPC.html#low_half_signed">low_half_signed</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_half_signed_type">low_half_signed_type</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_half_unsigned">low_half_unsigned</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_half_unsigned_type">low_half_unsigned_type</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_high_half_signed">low_high_half_signed</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#low_high_half_unsigned">low_high_half_unsigned</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<br/><br/><a name="axiom_M"></a><h2>M </h2>
-<a href="backend.RTLgen.html#more_likely">more_likely</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="lib.Floats.html#mul">mul</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><a name="axiom_N"></a><h2>N </h2>
-<a href="lib.Floats.html#neg">neg</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Integers.html#neg_mul_distr_l">neg_mul_distr_l</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#neg_mul_distr_r">neg_mul_distr_r</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<br/><br/><a name="axiom_O"></a><h2>O </h2>
-<a href="lib.Floats.html#one">one</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><a name="axiom_P"></a><h2>P </h2>
-<a href="lib.Coqlib.html#proof_irrelevance">proof_irrelevance</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<br/><br/><a name="axiom_S"></a><h2>S </h2>
-<a href="lib.Floats.html#singleoffloat">singleoffloat</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#singleoffloat_idem">singleoffloat_idem</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#sub">sub</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<a href="lib.Floats.html#subf_addf_opp">subf_addf_opp</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><a name="axiom_Z"></a><h2>Z </h2>
-<a href="lib.Floats.html#zero">zero</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><hr/>
-<h1>Lemma Index</h1>
-<a name="lemma_A"></a><h2>A </h2>
-<a href="backend.Values.html#addf_commut">addf_commut</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.PPCgenproof1.html#addimm_correct">addimm_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#addimm_1_correct">addimm_1_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#addimm_2_correct">addimm_2_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Mem.html#address_inject">address_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Constpropproof.html#addr_strength_reduction_correct">addr_strength_reduction_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="lib.Integers.html#add_and">add_and</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#add_assoc">add_assoc</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#add_assoc">add_assoc</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Allocproof.html#add_call_correct">add_call_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="lib.Integers.html#add_commut">add_commut</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#add_commut">add_commut</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Allocproof.html#add_cond_correct">add_cond_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instrs_correct">add_edges_instrs_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instrs_correct_aux">add_edges_instrs_correct_aux</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instrs_incl_aux">add_edges_instrs_incl_aux</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instr_correct">add_edges_instr_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_edges_instr_incl">add_edges_instr_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Allocproof.html#add_entry_correct">add_entry_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Globalenvs.html#add_functs_transf">add_functs_transf</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_instr_at">add_instr_at</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_instr_incr">add_instr_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#add_instr_wf">add_instr_wf</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_correct">add_interf_call_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_correct_aux_1">add_interf_call_correct_aux_1</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_correct_aux_2">add_interf_call_correct_aux_2</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_incl">add_interf_call_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_incl_aux_1">add_interf_call_incl_aux_1</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_call_incl_aux_2">add_interf_call_incl_aux_2</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_correct">add_interf_correct</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_entry_correct">add_interf_entry_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_entry_incl">add_interf_entry_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_incl">add_interf_incl</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_live_correct">add_interf_live_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_live_correct_aux">add_interf_live_correct_aux</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_live_incl">add_interf_live_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_live_incl_aux">add_interf_live_incl_aux</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_move_correct">add_interf_move_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_move_incl">add_interf_move_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_mreg_correct">add_interf_mreg_correct</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_mreg_incl">add_interf_mreg_incl</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_op_correct">add_interf_op_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_op_incl">add_interf_op_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_params_correct">add_interf_params_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_params_correct_aux">add_interf_params_correct_aux</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_params_incl">add_interf_params_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#add_interf_params_incl_aux">add_interf_params_incl_aux</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_letvar_wf">add_letvar_wf</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#add_load_correct">add_load_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.CSEproof.html#add_load_satisfiable">add_load_satisfiable</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.RTLgenproof.html#add_move_correct">add_move_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Allocproof.html#add_move_correct">add_move_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_move_incr">add_move_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="lib.Integers.html#add_neg_zero">add_neg_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Allocproof.html#add_op_correct">add_op_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.CSEproof.html#add_op_satisfiable">add_op_satisfiable</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Values.html#add_permut">add_permut</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#add_permut">add_permut</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#add_permut_4">add_permut_4</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Coloringproof.html#add_prefs_call_incl">add_prefs_call_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#add_pref_incl">add_pref_incl</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#add_pref_mreg_incl">add_pref_mreg_incl</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Allocproof.html#add_reloads_correct">add_reloads_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#add_reloads_correct_rec">add_reloads_correct_rec</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#add_reload_correct">add_reload_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#add_return_correct">add_return_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.CSEproof.html#add_rhs_satisfiable">add_rhs_satisfiable</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.Integers.html#add_signed">add_signed</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Allocproof.html#add_spill_correct">add_spill_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#add_store_correct">add_store_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Kildall.html#add_successors_correct">add_successors_correct</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#add_to_worklist_1">add_to_worklist_1</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#add_to_worklist_2">add_to_worklist_2</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Allocproof.html#add_undefs_correct">add_undefs_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="lib.Integers.html#add_unsigned">add_unsigned</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_vars_incr">add_vars_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_vars_letenv">add_vars_letenv</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_vars_valid">add_vars_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_vars_wf">add_vars_wf</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_find">add_var_find</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_incr">add_var_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_letenv">add_var_letenv</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_valid">add_var_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#add_var_wf">add_var_wf</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="lib.Integers.html#add_zero">add_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Allocproof.html#agree_assign_dead">agree_assign_dead</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_assign_live">agree_assign_live</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_call">agree_call</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Stackingproof.html#agree_eval_reg">agree_eval_reg</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_eval_reg">agree_eval_reg</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Stackingproof.html#agree_eval_regs">agree_eval_regs</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_eval_regs">agree_eval_regs</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_exten">agree_exten</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_exten_1">agree_exten_1</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_exten_2">agree_exten_2</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#agree_increasing">agree_increasing</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_init_regs">agree_init_regs</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_move_live">agree_move_live</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_nextinstr">agree_nextinstr</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_nextinstr_commut">agree_nextinstr_commut</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#agree_parameters">agree_parameters</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_reg_list_live">agree_reg_list_live</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_reg_live">agree_reg_live</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#agree_reg_sum_live">agree_reg_sum_live</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Stackingproof.html#agree_return_regs">agree_return_regs</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_commut">agree_set_commut</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Stackingproof.html#agree_set_local">agree_set_local</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mfreg">agree_set_mfreg</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mireg">agree_set_mireg</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mireg_exten">agree_set_mireg_exten</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mireg_twice">agree_set_mireg_twice</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_mreg">agree_set_mreg</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_other">agree_set_other</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Stackingproof.html#agree_set_outgoing">agree_set_outgoing</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#agree_set_reg">agree_set_reg</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree_set_twice_mireg">agree_set_twice_mireg</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="lib.Coqlib.html#align_le">align_le</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Alloctyping.html#allocs_write_ok">allocs_write_ok</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Mem.html#alloc_extends">alloc_extends</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#alloc_mapped_inject">alloc_mapped_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Coloringproof.html#alloc_of_coloring_correct_1">alloc_of_coloring_correct_1</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#alloc_of_coloring_correct_2">alloc_of_coloring_correct_2</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#alloc_of_coloring_correct_3">alloc_of_coloring_correct_3</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#alloc_of_coloring_correct_4">alloc_of_coloring_correct_4</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_regs_fresh_or_in_map">alloc_regs_fresh_or_in_map</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_regs_incr">alloc_regs_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_regs_target_ok">alloc_regs_target_ok</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_regs_valid">alloc_regs_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_reg_fresh_or_in_map">alloc_reg_fresh_or_in_map</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_reg_incr">alloc_reg_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_reg_target_ok">alloc_reg_target_ok</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#alloc_reg_valid">alloc_reg_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Mem.html#alloc_right_inject">alloc_right_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Alloctyping.html#alloc_type">alloc_type</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#alloc_types">alloc_types</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Mem.html#alloc_unmapped_inject">alloc_unmapped_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#alloc_variables_list_block">alloc_variables_list_block</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#alloc_variables_nextblock_incr">alloc_variables_nextblock_incr</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Alloctyping.html#alloc_write_ok">alloc_write_ok</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_aux_1">all_interf_regs_correct_aux_1</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_aux_2">all_interf_regs_correct_aux_2</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_aux_3">all_interf_regs_correct_aux_3</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_1">all_interf_regs_correct_1</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs_correct_2">all_interf_regs_correct_2</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.CSEproof.html#analysis_correct_entry">analysis_correct_entry</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#analysis_correct_N">analysis_correct_N</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#analysis_correct_1">analysis_correct_1</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Allocproof.html#analyze_correct">analyze_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Constpropproof.html#analyze_correct_1">analyze_correct_1</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#analyze_correct_2">analyze_correct_2</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#analyze_correct_3">analyze_correct_3</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Kildall.html#analyze_invariant">analyze_invariant</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#analyze_P">analyze_P</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.PPCgenproof1.html#andimm_correct">andimm_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Values.html#and_assoc">and_assoc</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#and_assoc">and_assoc</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_commut">and_commut</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#and_commut">and_commut</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#and_idem">and_idem</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_mone">and_mone</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_or_distrib">and_or_distrib</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_shl">and_shl</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_shru">and_shru</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_xor_distrib">and_xor_distrib</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#and_zero">and_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Parallelmove.html#appcons_length">appcons_length</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Maps.html#append_assoc_0">append_assoc_0</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#append_assoc_1">append_assoc_1</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#append_injective">append_injective</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#append_neutral_l">append_neutral_l</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#append_neutral_r">append_neutral_r</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Main.html#apply_total_transf_program">apply_total_transf_program</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Constpropproof.html#approx_regs_val_list">approx_regs_val_list</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Parallelmove.html#app_app">app_app</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_cons">app_cons</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_nil">app_nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_rewrite">app_rewrite</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_rewriter">app_rewriter</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#app_rewrite2">app_rewrite2</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Conventions.html#arguments_not_preserved">arguments_not_preserved</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<br/><br/><a name="lemma_B"></a><h2>B </h2>
-<a href="backend.Cminorgenproof.html#bind_parameters_length">bind_parameters_length</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_above">bits_of_Z_above</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_below">bits_of_Z_below</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_mone">bits_of_Z_mone</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_of_bits">bits_of_Z_of_bits</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z_zero">bits_of_Z_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_assoc">bitwise_binop_assoc</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_commut">bitwise_binop_commut</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_idem">bitwise_binop_idem</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_rol">bitwise_binop_rol</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_shl">bitwise_binop_shl</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop_shru">bitwise_binop_shru</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Mem.html#block_agree_refl">block_agree_refl</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_agree_sym">block_agree_sym</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_agree_trans">block_agree_trans</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_exten">block_contents_exten</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_inject_incr">block_contents_inject_incr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_cont_val">block_cont_val</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Values.html#bool_of_false_val">bool_of_false_val</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_false_val2">bool_of_false_val2</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_false_val_inv">bool_of_false_val_inv</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_true_val">bool_of_true_val</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_true_val2">bool_of_true_val2</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#bool_of_true_val_inv">bool_of_true_val_inv</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Mem.html#bounds_free_block">bounds_free_block</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Lineartyping.html#bound_float_callee_save_pos">bound_float_callee_save_pos</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#bound_float_local_pos">bound_float_local_pos</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#bound_int_callee_save_pos">bound_int_callee_save_pos</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#bound_int_local_pos">bound_int_local_pos</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#bound_outgoing_pos">bound_outgoing_pos</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Tunnelingproof.html#branch_target_characterization">branch_target_characterization</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#branch_target_rec_1">branch_target_rec_1</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#branch_target_rec_2">branch_target_rec_2</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<br/><br/><a name="lemma_C"></a><h2>C </h2>
-<a href="backend.Machabstr2mach.html#callstack_dom_diff">callstack_dom_diff</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_dom_incr">callstack_dom_incr</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_dom_less">callstack_dom_less</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_exten">callstack_exten</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_function_entry">callstack_function_entry</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_function_return">callstack_function_return</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_get_parent">callstack_get_parent</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_get_slot">callstack_get_slot</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_init">callstack_init</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_load">callstack_load</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_set_slot">callstack_set_slot</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_store">callstack_store</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_store_aux">callstack_store_aux</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_store_ok">callstack_store_ok</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Allocproof.html#call_regs_param_of_arg">call_regs_param_of_arg</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="lib.Integers.html#cast16unsigned_and">cast16unsigned_and</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cast16unsigned_and">cast16unsigned_and</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cast16_signed_equal_if_unsigned_equal">cast16_signed_equal_if_unsigned_equal</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast16_signed_idem">cast16_signed_idem</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast16_unsigned_idem">cast16_unsigned_idem</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast16_unsigned_signed">cast16_unsigned_signed</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8unsigned_and">cast8unsigned_and</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cast8unsigned_and">cast8unsigned_and</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cast8_signed_equal_if_unsigned_equal">cast8_signed_equal_if_unsigned_equal</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8_signed_idem">cast8_signed_idem</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8_signed_unsigned">cast8_signed_unsigned</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8_unsigned_idem">cast8_unsigned_idem</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#cast8_unsigned_signed">cast8_unsigned_signed</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Inclusion.html#check_all_leaves_sound">check_all_leaves_sound</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Coloringproof.html#check_coloring_1_correct">check_coloring_1_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#check_coloring_2_correct">check_coloring_2_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#check_coloring_3_correct">check_coloring_3_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Mem.html#check_cont_agree">check_cont_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#check_cont_false">check_cont_false</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#check_cont_inject">check_cont_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#check_cont_inv">check_cont_inv</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#check_cont_true">check_cont_true</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Integers.html#check_equal_on_range_correct">check_equal_on_range_correct</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Linearizetyping.html#cleanup_code_conservation">cleanup_code_conservation</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizetyping.html#cleanup_code_conservation_2">cleanup_code_conservation_2</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizeproof.html#cleanup_code_correct_1">cleanup_code_correct_1</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#cleanup_code_correct_2">cleanup_code_correct_2</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizetyping.html#cleanup_function_conservation">cleanup_function_conservation</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizetyping.html#cleanup_function_conservation_2">cleanup_function_conservation_2</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizeproof.html#cleanup_function_correct">cleanup_function_correct</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Values.html#cmpf_ge">cmpf_ge</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmpf_is_bool">cmpf_is_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmpf_le">cmpf_le</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmpu_is_bool">cmpu_is_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmp_is_bool">cmp_is_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmp_mismatch_is_bool">cmp_mismatch_is_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.PPCgenproof.html#code_tail_next">code_tail_next</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#code_tail_next_int">code_tail_next_int</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="lib.Maps.html#combine_commut">combine_commut</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Ordered.html#compare">compare</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#compare">compare</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#compare">compare</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.PPCgenproof1.html#compare_float_spec">compare_float_spec</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#compare_sint_spec">compare_sint_spec</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#compare_uint_spec">compare_uint_spec</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Constpropproof.html#cond_strength_reduction_correct">cond_strength_reduction_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.RTLtyping.html#consistent_not_eq">consistent_not_eq</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#cons_replace">cons_replace</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Mem.html#contentmap_inject_incr">contentmap_inject_incr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_incr">content_inject_incr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Coloringproof.html#correct_interf_alloc_instr">correct_interf_alloc_instr</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#correct_interf_instr_incl">correct_interf_instr_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<br/><br/><a name="lemma_D"></a><h2>D </h2>
-<a href="backend.RTLtyping.html#definite_included">definite_included</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Locations.html#diff_not_eq">diff_not_eq</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#diff_sym">diff_sym</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Kildall.html#discard_top_worklist_invariant">discard_top_worklist_invariant</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#disc1">disc1</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#disc2">disc2</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#disjoint_cons_left">disjoint_cons_left</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#disjoint_cons_right">disjoint_cons_right</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#disjoint_notin">disjoint_notin</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#disjoint_sym">disjoint_sym</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#disjoint_tmp__noTmp">disjoint_tmp__noTmp</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#dis_dsttmp1_pnilnil">dis_dsttmp1_pnilnil</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#dis_srctmp1_pnilnil">dis_srctmp1_pnilnil</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="lib.Integers.html#divs_pow2">divs_pow2</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#divs_pow2">divs_pow2</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#divu_pow2">divu_pow2</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#divu_pow2">divu_pow2</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1src_inv">Done_notmp1src_inv</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1src_invf">Done_notmp1src_invf</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1src_invpp">Done_notmp1src_invpp</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1src_res">Done_notmp1src_res</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1_inv">Done_notmp1_inv</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1_invf">Done_notmp1_invf</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1_invpp">Done_notmp1_invpp</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp1_res">Done_notmp1_res</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp3_inv">Done_notmp3_inv</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp3_invf">Done_notmp3_invf</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp3_invpp">Done_notmp3_invpp</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_notmp3_res">Done_notmp3_res</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp_sameExec">dstepp_sameExec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp_stepp">dstepp_stepp</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_inv">dstep_inv</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_inv_getdst">dstep_inv_getdst</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_step">dstep_step</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#dst_tmp2_res">dst_tmp2_res</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#dst_tmp2_step">dst_tmp2_step</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#dst_tmp2_stepf">dst_tmp2_stepf</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#dst_tmp2_stepp">dst_tmp2_stepp</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<br/><br/><a name="lemma_E"></a><h2>E </h2>
-<a href="lib.Maps.html#elements_complete">elements_complete</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Sets.html#elements_complete">elements_complete</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#elements_correct">elements_correct</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Sets.html#elements_correct">elements_correct</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#elements_keys_norepet">elements_keys_norepet</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.CSE.html#empty_numbering_satisfiable">empty_numbering_satisfiable</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.RTLtyping.html#encode_decode">encode_decode</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#encode_injective">encode_injective</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Allocproof.html#entrypoint_function_translated">entrypoint_function_translated</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Linearizeproof.html#enumerate_complete">enumerate_complete</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#enumerate_head">enumerate_head</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#enumerate_norepet">enumerate_norepet</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Constprop.html#eq">eq</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#eq">eq</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#eq">eq</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#eq">eq</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#eq">eq</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Locations.html#eq">eq</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#eq">eq</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#eq">eq</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Integers.html#eqmod_add">eqmod_add</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_mod">eqmod_mod</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_mod_eq">eqmod_mod_eq</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_mult">eqmod_mult</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_neg">eqmod_neg</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_refl">eqmod_refl</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_refl2">eqmod_refl2</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_small_eq">eqmod_small_eq</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_sub">eqmod_sub</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_sym">eqmod_sym</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_trans">eqmod_trans</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_256_unsigned_repr">eqmod_256_unsigned_repr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod_65536_unsigned_repr">eqmod_65536_unsigned_repr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_add">eqm_add</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_mult">eqm_mult</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_neg">eqm_neg</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_refl">eqm_refl</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_refl2">eqm_refl2</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_samerepr">eqm_samerepr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_signed_unsigned">eqm_signed_unsigned</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_small_eq">eqm_small_eq</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_sub">eqm_sub</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_sym">eqm_sym</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_trans">eqm_trans</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_unsigned_repr">eqm_unsigned_repr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_unsigned_repr_l">eqm_unsigned_repr_l</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm_unsigned_repr_r">eqm_unsigned_repr_r</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLtyping.html#equal_eq">equal_eq</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Integers.html#equal_on_range">equal_on_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.CSEproof.html#equation_evals_to_holds_1">equation_evals_to_holds_1</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#equation_evals_to_holds_2">equation_evals_to_holds_2</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.Integers.html#eq_dec">eq_dec</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eq_false">eq_false</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Ordered.html#eq_refl">eq_refl</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_refl">eq_refl</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_refl">eq_refl</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Integers.html#eq_spec">eq_spec</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Ordered.html#eq_sym">eq_sym</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_sym">eq_sym</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Integers.html#eq_sym">eq_sym</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Ordered.html#eq_sym">eq_sym</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_trans">eq_trans</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_trans">eq_trans</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#eq_trans">eq_trans</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Integers.html#eq_true">eq_true</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLtyping.html#error_inconsistent">error_inconsistent</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_absfloat">eval_absfloat</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_add">eval_add</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_addf">eval_addf</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_addimm">eval_addimm</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_addimm_ptr">eval_addimm_ptr</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_addressing">eval_addressing</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_addressing_preserved">eval_addressing_preserved</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_addressing_weaken">eval_addressing_weaken</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_add_ptr">eval_add_ptr</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_add_ptr_2">eval_add_ptr_2</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_and">eval_and</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_andimm">eval_andimm</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_base_condition_of_expr">eval_base_condition_of_expr</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cast16signed">eval_cast16signed</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cast16unsigned">eval_cast16unsigned</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cast8signed">eval_cast8signed</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cast8unsigned">eval_cast8unsigned</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmp">eval_cmp</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmpf">eval_cmpf</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmpu">eval_cmpu</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmp_null_l">eval_cmp_null_l</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmp_null_r">eval_cmp_null_r</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_cmp_ptr">eval_cmp_ptr</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_compare_null_weaken">eval_compare_null_weaken</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_conditionalexpr_false">eval_conditionalexpr_false</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_conditionalexpr_true">eval_conditionalexpr_true</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_condition_of_expr">eval_condition_of_expr</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_condition_total_is_bool">eval_condition_total_is_bool</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_condition_weaken">eval_condition_weaken</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_divf">eval_divf</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_divs">eval_divs</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_divu">eval_divu</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_divu_base">eval_divu_base</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_floatofint">eval_floatofint</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_floatofintu">eval_floatofintu</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_intoffloat">eval_intoffloat</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_lift">eval_lift</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_lift_expr">eval_lift_expr</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_load">eval_load</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mods">eval_mods</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_modu">eval_modu</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mod_aux">eval_mod_aux</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mul">eval_mul</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mulf">eval_mulf</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mulimm">eval_mulimm</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_mulimm_base">eval_mulimm_base</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_negate_condition">eval_negate_condition</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_negfloat">eval_negfloat</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_negint">eval_negint</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_notbool">eval_notbool</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_notbool_base">eval_notbool_base</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_notint">eval_notint</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Op.html#eval_operation_preserved">eval_operation_preserved</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_operation_weaken">eval_operation_weaken</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_or">eval_or</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_rolm">eval_rolm</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shl">eval_shl</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shlimm">eval_shlimm</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shr">eval_shr</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shru">eval_shru</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_shruimm">eval_shruimm</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_singleoffloat">eval_singleoffloat</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Constpropproof.html#eval_static_condition_correct">eval_static_condition_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#eval_static_operation_correct">eval_static_operation_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_store">eval_store</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_sub">eval_sub</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_subf">eval_subf</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_sub_ptr_int">eval_sub_ptr_int</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_sub_ptr_ptr">eval_sub_ptr_ptr</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#eval_xor">eval_xor</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_blocks_Bgoto_inv">exec_blocks_Bgoto_inv</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.LTL.html#exec_blocks_extends">exec_blocks_extends</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_blocks_valid_outcome">exec_blocks_valid_outcome</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_block_Bgoto_inv">exec_block_Bgoto_inv</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_function_body_prop_">exec_function_body_prop_</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_function_equiv">exec_function_equiv</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_function_prop_">exec_function_prop_</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#exec_ifthenelse_false">exec_ifthenelse_false</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#exec_ifthenelse_true">exec_ifthenelse_true</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.RTL.html#exec_Iload'">exec_Iload'</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_instrs_Bgoto_inv">exec_instrs_Bgoto_inv</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instrs_extends">exec_instrs_extends</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instrs_extends_rec">exec_instrs_extends_rec</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Stackingproof.html#exec_instrs_incl">exec_instrs_incl</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_instrs_incl">exec_instrs_incl</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instrs_incr">exec_instrs_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Machtyping.html#exec_instrs_link_invariant">exec_instrs_link_invariant</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Allocproof_aux.html#exec_instrs_pmov">exec_instrs_pmov</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.RTL.html#exec_instrs_present">exec_instrs_present</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_extends">exec_instr_extends</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_extends_rec">exec_instr_extends_rec</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_instr_incl">exec_instr_incl</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#exec_instr_incl">exec_instr_incl</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_incr">exec_instr_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_in_s2">exec_instr_in_s2</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Machtyping.html#exec_instr_link_invariant">exec_instr_link_invariant</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLgenproof1.html#exec_instr_not_halt">exec_instr_not_halt</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTL.html#exec_instr_present">exec_instr_present</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Allocproof_aux.html#exec_instr_update">exec_instr_update</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.RTL.html#exec_Iop'">exec_Iop'</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mcall_prop">exec_Mcall_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mcond_false_prop">exec_Mcond_false_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mcond_true_prop">exec_Mcond_true_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mgetparam_prop">exec_Mgetparam_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#exec_Mgetstack'">exec_Mgetstack'</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mgetstack_prop">exec_Mgetstack_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mgoto_prop">exec_Mgoto_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mlabel_prop">exec_Mlabel_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mload_prop">exec_Mload_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mop_prop">exec_Mop_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#exec_Msetstack'">exec_Msetstack'</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Msetstack_prop">exec_Msetstack_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_Mstore_prop">exec_Mstore_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Machabstr.html#exec_mutual_induction">exec_mutual_induction</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_one_prop">exec_one_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_program_equiv">exec_program_equiv</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_refl_prop">exec_refl_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTL.html#exec_step">exec_step</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_straight_exec_prop">exec_straight_exec_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_one">exec_straight_one</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_straight_steps">exec_straight_steps</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_straight_steps_1">exec_straight_steps_1</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_straight_steps_2">exec_straight_steps_2</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_three">exec_straight_three</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_trans">exec_straight_trans</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_two">exec_straight_two</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_trans_prop">exec_trans_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#expr_condexpr_exprlist_ind">expr_condexpr_exprlist_ind</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="lib.Maps.html#exten">exten</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Mem.html#extends_refl">extends_refl</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#extend_inject_incr">extend_inject_incr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<br/><br/><a name="lemma_F"></a><h2>F </h2>
-<a href="backend.Globalenvs.html#find_funct_find_funct_ptr">find_funct_find_funct_ptr</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_inv">find_funct_inv</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_prop">find_funct_prop</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr_inv">find_funct_ptr_inv</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr_prop">find_funct_ptr_prop</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr_transf">find_funct_ptr_transf</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr_transf_partial">find_funct_ptr_transf_partial</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_transf">find_funct_transf</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_transf_partial">find_funct_transf_partial</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.PPCgenproof.html#find_instr_in">find_instr_in</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#find_instr_tail">find_instr_tail</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_cleanup_code">find_label_cleanup_code</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.PPCgenproof.html#find_label_goto_label">find_label_goto_label</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#find_label_incl">find_label_incl</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_lin">find_label_lin</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_lin_block">find_label_lin_block</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_lin_rec">find_label_lin_rec</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Stackingproof.html#find_label_transl_code">find_label_transl_code</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#find_label_unique">find_label_unique</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_letvar_incr">find_letvar_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_letvar_in_map">find_letvar_in_map</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_letvar_not_mutated">find_letvar_not_mutated</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_letvar_valid">find_letvar_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.CSEproof.html#find_load_correct">find_load_correct</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#find_op_correct">find_op_correct</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#find_rhs_correct">find_rhs_correct</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Globalenvs.html#find_symbol_inv">find_symbol_inv</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_symbol_transf">find_symbol_transf</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#find_symbol_transf_partial">find_symbol_transf_partial</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.CSEproof.html#find_valnum_rhs_correct">find_valnum_rhs_correct</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_var_incr">find_var_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_var_in_map">find_var_in_map</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_var_not_mutated">find_var_not_mutated</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#find_var_valid">find_var_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_entry">fixpoint_entry</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_entry">fixpoint_entry</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_entry">fixpoint_entry</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_incr">fixpoint_incr</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_invariant">fixpoint_invariant</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_solution">fixpoint_solution</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_solution">fixpoint_solution</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint_solution">fixpoint_solution</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="lib.Inclusion.html#flatten_aux_valid_A">flatten_aux_valid_A</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#flatten_valid_A">flatten_valid_A</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.PPCgenproof1.html#floatcomp_correct">floatcomp_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Linearizetyping.html#float_callee_save_bound">float_callee_save_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Conventions.html#float_callee_save_norepet">float_callee_save_norepet</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#float_callee_save_not_destroyed">float_callee_save_not_destroyed</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#float_callee_save_type">float_callee_save_type</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Linearizetyping.html#float_local_slot_bound">float_local_slot_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="lib.Maps.html#fold_spec">fold_spec</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Sets.html#fold_spec">fold_spec</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Sets.html#for_all_spec">for_all_spec</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct">Fpmov_correct</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correctMoves">Fpmov_correctMoves</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct1">Fpmov_correct1</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct2">Fpmov_correct2</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct_ext">Fpmov_correct_ext</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct_IT3">Fpmov_correct_IT3</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Fpmov_correct_map">Fpmov_correct_map</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_alloc">frame_match_alloc</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_exten">frame_match_exten</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_free">frame_match_free</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_get_slot">frame_match_get_slot</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_load">frame_match_load</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_new">frame_match_new</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_set_slot">frame_match_set_slot</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_store">frame_match_store</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_store_ok">frame_match_store_ok</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_store_stack_other">frame_match_store_stack_other</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Mem.html#free_empty_bounds">free_empty_bounds</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_extends">free_extends</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_first_inject">free_first_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_first_list_inject">free_first_list_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_inject">free_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_snd_inject">free_snd_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPC.html#freg_eq">freg_eq</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#freg_of_is_data_reg">freg_of_is_data_reg</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#freg_of_not_FPR13">freg_of_not_FPR13</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#freg_val">freg_val</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Mem.html#fresh_block_alloc">fresh_block_alloc</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Globalenvs.html#functions_globalenv">functions_globalenv</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Constpropproof.html#functions_translated">functions_translated</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#functions_translated">functions_translated</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.PPCgenproof.html#functions_translated">functions_translated</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Allocproof.html#functions_translated">functions_translated</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Linearizeproof.html#functions_translated">functions_translated</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Stackingproof.html#functions_translated">functions_translated</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.CSEproof.html#functions_translated">functions_translated</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#functions_translated">functions_translated</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#functions_translated">functions_translated</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#functions_translated_no_overflow">functions_translated_no_overflow</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#functions_translated_2">functions_translated_2</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#function_entry_ok">function_entry_ok</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Linearizeproof.html#function_ptr_translated">function_ptr_translated</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Allocproof.html#function_ptr_translated">function_ptr_translated</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Stackingproof.html#function_ptr_translated">function_ptr_translated</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#function_ptr_translated">function_ptr_translated</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#function_ptr_translated">function_ptr_translated</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Constpropproof.html#function_ptr_translated">function_ptr_translated</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#function_ptr_translated">function_ptr_translated</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.CSEproof.html#funct_ptr_translated">funct_ptr_translated</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Parallelmove.html#f2ind">f2ind</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#f2ind'">f2ind'</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<br/><br/><a name="lemma_G"></a><h2>G </h2>
-<a href="lib.Maps.html#gcombine">gcombine</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gempty">gempty</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Parallelmove.html#getdst_add">getdst_add</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#getdst_app">getdst_app</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#getdst_f">getdst_f</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#getdst_lists2moves">getdst_lists2moves</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#getdst_map">getdst_map</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Mem.html#getN_agree">getN_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_init">getN_init</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_inject">getN_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_setN_mismatch">getN_setN_mismatch</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_setN_other">getN_setN_other</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_setN_overlap">getN_setN_overlap</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#getN_setN_same">getN_setN_same</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Allocproof_aux.html#getsrcdst_app">getsrcdst_app</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc_add">getsrc_add</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc_add1">getsrc_add1</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc_app">getsrc_app</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#getsrc_f">getsrc_f</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc_map">getsrc_map</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLtyping.html#get_add_1">get_add_1</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#get_add_2">get_add_2</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Lattice.html#get_bot">get_bot</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.RTLtyping.html#get_empty">get_empty</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#get_noWrite">get_noWrite</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#get_pexec_id_noWrite">get_pexec_id_noWrite</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Stackingproof.html#get_slot_index">get_slot_index</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#get_slot_ok">get_slot_ok</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="lib.Lattice.html#get_top">get_top</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Parallelmove.html#get_update">get_update</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#get_update_diff">get_update_diff</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#get_update_id">get_update_id</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#get_update_ndiff">get_update_ndiff</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Maps.html#get_xget_h">get_xget_h</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#ge_bot">ge_bot</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_bot">ge_bot</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge_bot">ge_bot</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#ge_bot">ge_bot</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge_bot">ge_bot</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge_lub_left">ge_lub_left</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge_lub_left">ge_lub_left</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Constprop.html#ge_lub_left">ge_lub_left</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge_lub_left">ge_lub_left</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_lub_left">ge_lub_left</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge_lub_right">ge_lub_right</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#ge_refl">ge_refl</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge_refl">ge_refl</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#ge_refl">ge_refl</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_refl">ge_refl</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge_refl">ge_refl</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge_top">ge_top</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge_top">ge_top</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge_top">ge_top</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_top">ge_top</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_trans">ge_trans</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge_trans">ge_trans</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Sets.html#ge_trans">ge_trans</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#ge_trans">ge_trans</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#ge_trans">ge_trans</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#gi">gi</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gi">gi</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gi">gi</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gleaf">gleaf</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gmap">gmap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gmap">gmap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gmap">gmap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gmap">gmap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.PPCgenproof1.html#gpr_or_zero_not_zero">gpr_or_zero_not_zero</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#gpr_or_zero_zero">gpr_or_zero_zero</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Coloringproof.html#graph_incl_refl">graph_incl_refl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#graph_incl_trans">graph_incl_trans</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="lib.Maps.html#gro">gro</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#grs">grs</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsident">gsident</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsident">gsident</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsident">gsident</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gso">gso</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#gso">gso</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#gso">gso</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gso">gso</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#gso">gso</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#gso">gso</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gss">gss</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gss">gss</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#gss">gss</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#gss">gss</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#gss">gss</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#gss">gss</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsspec">gsspec</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsspec">gsspec</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsspec">gsspec</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#gsspec">gsspec</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<br/><br/><a name="lemma_H"></a><h2>H </h2>
-<a href="backend.Mem.html#high_bound_alloc">high_bound_alloc</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#high_bound_free">high_bound_free</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#high_bound_store">high_bound_store</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgenproof1.html#high_half_signed_zero">high_half_signed_zero</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#high_half_unsigned_zero">high_half_unsigned_zero</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<br/><br/><a name="lemma_I"></a><h2>I </h2>
-<a href="lib.union_find.html#identify_aux_decomp">identify_aux_decomp</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_a_maps_to_b">identify_base_a_maps_to_b</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_b_canon">identify_base_b_canon</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_order_wf">identify_base_order_wf</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_repr">identify_base_repr</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_repr_order">identify_base_repr_order</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_sameclass_1">identify_base_sameclass_1</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base_sameclass_2">identify_base_sameclass_2</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.RTLtyping.html#included_consistent">included_consistent</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_identify">included_identify</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_mapped">included_mapped</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_mapped_forall">included_mapped_forall</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_refl">included_refl</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#included_trans">included_trans</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Inclusion.html#inclusion_theorem">inclusion_theorem</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Coqlib.html#incl_app_inv_l">incl_app_inv_l</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#incl_app_inv_r">incl_app_inv_r</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#incl_cons_inv">incl_cons_inv</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Alloctyping_aux.html#incl_dst">incl_dst</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Machtyping.html#incl_find_label">incl_find_label</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Alloctyping_aux.html#incl_nil">incl_nil</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="lib.Coqlib.html#incl_same_head">incl_same_head</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Alloctyping_aux.html#incl_src">incl_src</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Stackingproof.html#index_arg_valid">index_arg_valid</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Conventions.html#index_float_callee_save_inj">index_float_callee_save_inj</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_float_callee_save_pos">index_float_callee_save_pos</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_float_callee_save_pos2">index_float_callee_save_pos2</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="lib.Maps.html#index_inj">index_inj</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#index_inj">index_inj</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#index_inj">index_inj</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Conventions.html#index_int_callee_save_inj">index_int_callee_save_inj</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_int_callee_save_pos">index_int_callee_save_pos</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_int_callee_save_pos2">index_int_callee_save_pos2</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Stackingproof.html#index_local_valid">index_local_valid</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_saved_float_valid">index_saved_float_valid</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_saved_int_valid">index_saved_int_valid</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_val_init_frame">index_val_init_frame</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Parallelmove.html#Indst_noOverlap_aux">Indst_noOverlap_aux</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Ingetsrc_swap">Ingetsrc_swap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Ingetsrc_swap2">Ingetsrc_swap2</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Kildall.html#initial_state_invariant">initial_state_invariant</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Globalenvs.html#initmem_nullptr">initmem_nullptr</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#initmem_undef">initmem_undef</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.RTLgenproof1.html#init_mapping_wf">init_mapping_wf</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Globalenvs.html#init_mem_transf">init_mem_transf</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#init_mem_transf_partial">init_mem_transf_partial</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.RTLgen.html#init_state_wf">init_state_wf</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Mem.html#inject_incr_refl">inject_incr_refl</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#inject_incr_trans">inject_incr_trans</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Inclusion.html#insert_bin_included">insert_bin_included</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv_lookup1">insert_lenv_lookup1</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv_lookup2">insert_lenv_lookup2</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#instr_at_incr">instr_at_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Coloringproof.html#interfere_incl">interfere_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#interfere_mreg_incl">interfere_mreg_incl</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.InterfGraph.html#interfere_sym">interfere_sym</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloringproof.html#interf_graph_correct_1">interf_graph_correct_1</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#interf_graph_correct_2">interf_graph_correct_2</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#interf_graph_correct_3">interf_graph_correct_3</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Constpropproof.html#intval_correct">intval_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#int_add_no_overflow">int_add_no_overflow</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Linearizetyping.html#int_callee_save_bound">int_callee_save_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Conventions.html#int_callee_save_norepet">int_callee_save_norepet</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#int_callee_save_not_destroyed">int_callee_save_not_destroyed</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#int_callee_save_type">int_callee_save_type</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#int_float_callee_save_disjoint">int_float_callee_save_disjoint</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Linearizetyping.html#int_local_slot_bound">int_local_slot_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Cmconstrproof.html#inv_eval_Eop_0">inv_eval_Eop_0</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#inv_eval_Eop_1">inv_eval_Eop_1</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#inv_eval_Eop_2">inv_eval_Eop_2</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Mem.html#in_bounds_exten">in_bounds_exten</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#in_bounds_holds">in_bounds_holds</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#in_bounds_inject">in_bounds_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Allocproof_aux.html#in_cons_noteq">in_cons_noteq</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Kildall.html#in_incr_refl">in_incr_refl</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#in_incr_trans">in_incr_trans</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#In_Indst">In_Indst</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#in_move__in_srcdst">in_move__in_srcdst</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#In_norepet">In_norepet</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Locations.html#in_notin_diff">in_notin_diff</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#In_noTmp_notempo">In_noTmp_notempo</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Inclusion.html#in_or_insert_bin">in_or_insert_bin</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Machabstr2mach.html#in_or_notin_callstack">in_or_notin_callstack</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="lib.Inclusion.html#In_permute_app_head">In_permute_app_head</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Integers.html#in_range_range">in_range_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Inclusion.html#in_remove_head">in_remove_head</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Parallelmove.html#In_SD_diff">In_SD_diff</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#In_SD_diff'">In_SD_diff'</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#In_SD_no_o">In_SD_no_o</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#in_split_move">in_split_move</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="lib.Maps.html#in_xelements">in_xelements</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#in_xkeys">in_xkeys</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.PPC.html#ireg_eq">ireg_eq</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#ireg_of_is_data_reg">ireg_of_is_data_reg</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#ireg_of_not_GPR1">ireg_of_not_GPR1</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#ireg_of_not_GPR2">ireg_of_not_GPR2</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#ireg_val">ireg_val</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Values.html#isfalse_not_istrue">isfalse_not_istrue</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#istrue_not_isfalse">istrue_not_isfalse</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Tunnelingproof.html#is_goto_block_correct">is_goto_block_correct</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.PPC.html#is_label_correct">is_label_correct</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#is_label_correct">is_label_correct</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Linear.html#is_label_correct">is_label_correct</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Op.html#is_move_operation_correct">is_move_operation_correct</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Integers.html#is_power2_correct">is_power2_correct</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#is_power2_range">is_power2_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#is_power2_rng">is_power2_rng</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_cons_left">is_tail_cons_left</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_exec_instr">is_tail_exec_instr</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_exec_instrs">is_tail_exec_instrs</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_find_label">is_tail_find_label</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_in">is_tail_in</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Kildall.html#iterate_base">iterate_base</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#iterate_incr">iterate_incr</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#iterate_solution">iterate_solution</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#iterate_step">iterate_step</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<br/><br/><a name="lemma_K"></a><h2>K </h2>
-<a href="backend.CSEproof.html#kill_load_eqs_incl">kill_load_eqs_incl</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#kill_load_eqs_ops">kill_load_eqs_ops</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#kill_load_satisfiable">kill_load_satisfiable</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<br/><br/><a name="lemma_L"></a><h2>L </h2>
-<a href="backend.Linearizeproof.html#label_in_lin_block">label_in_lin_block</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#label_in_lin_rec">label_in_lin_rec</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.PPCgenproof.html#label_pos_code_tail">label_pos_code_tail</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Parallelmove.html#last_app">last_app</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#last_cons">last_cons</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#last_replace">last_replace</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof.html#length_addr_args">length_addr_args</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Parallelmove.html#length_app">length_app</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof.html#length_cond_args">length_cond_args</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#length_op_args">length_op_args</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Parallelmove.html#length_replace">length_replace</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLtyping.html#let_fold_args_res">let_fold_args_res</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Linearizetyping.html#linearize_block_incl">linearize_block_incl</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="lib.Coqlib.html#list_append_map">list_append_map</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint_cons_left">list_disjoint_cons_left</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint_cons_right">list_disjoint_cons_right</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint_notin">list_disjoint_notin</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint_sym">list_disjoint_sym</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_forall2_imply">list_forall2_imply</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_in_map_inv">list_in_map_inv</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_length_map">list_length_map</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_map_compose">list_map_compose</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_map_exten">list_map_exten</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_map_norepet">list_map_norepet</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_map_nth">list_map_nth</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_append">list_norepet_append</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_append_left">list_norepet_append_left</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_append_right">list_norepet_append_right</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_dec">list_norepet_dec</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.PPCgenproof1.html#loadimm_correct">loadimm_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#loadind_aux_correct">loadind_aux_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#loadind_correct">loadind_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Mem.html#loadv_inject">loadv_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgenproof.html#loadv_8_signed_unsigned">loadv_8_signed_unsigned</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Mem.html#load_agree">load_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_alloc_other">load_alloc_other</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_alloc_same">load_alloc_same</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_contentmap_agree">load_contentmap_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_contents_init">load_contents_init</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_contents_inject">load_contents_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_extends">load_extends</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_free">load_free</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#load_freelist">load_freelist</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#load_from_alloc_is_undef">load_from_alloc_is_undef</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#load_inject">load_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_inv">load_inv</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_in_bounds">load_in_bounds</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#load_result_idem">load_result_idem</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#load_result_inject">load_result_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#load_result_normalized">load_result_normalized</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#load_result_ty">load_result_ty</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Mem.html#load_store_contents_mismatch">load_store_contents_mismatch</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_contents_other">load_store_contents_other</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_contents_overlap">load_store_contents_overlap</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_contents_same">load_store_contents_same</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_other">load_store_other</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#load_store_same">load_store_same</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Conventions.html#locs_acceptable_disj_temporaries">locs_acceptable_disj_temporaries</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Allocproof.html#loc_acceptable_noteq_diff">loc_acceptable_noteq_diff</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#loc_acceptable_notin_notin">loc_acceptable_notin_notin</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_acceptable">loc_arguments_acceptable</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_bounded">loc_arguments_bounded</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_length">loc_arguments_length</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_norepet">loc_arguments_norepet</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_not_temporaries">loc_arguments_not_temporaries</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_type">loc_arguments_type</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Coloringproof.html#loc_is_acceptable_correct">loc_is_acceptable_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Conventions.html#loc_parameters_not_temporaries">loc_parameters_not_temporaries</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_parameters_type">loc_parameters_type</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_result_acceptable">loc_result_acceptable</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_result_type">loc_result_type</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Mem.html#low_bound_alloc">low_bound_alloc</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#low_bound_free">low_bound_free</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#low_bound_store">low_bound_store</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgenproof1.html#low_high_s">low_high_s</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#low_high_u">low_high_u</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#low_high_u_xor">low_high_u_xor</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="lib.Ordered.html#lt_not_eq">lt_not_eq</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_not_eq">lt_not_eq</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_not_eq">lt_not_eq</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_trans">lt_trans</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_trans">lt_trans</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt_trans">lt_trans</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Lattice.html#lub_commut">lub_commut</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#lub_commut">lub_commut</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#lub_commut">lub_commut</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#lub_commut">lub_commut</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#lub_commut">lub_commut</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<br/><br/><a name="lemma_M"></a><h2>M </h2>
-<a href="backend.Constpropproof.html#make_addimm_correct">make_addimm_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#make_andimm_correct">make_andimm_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_cast_correct">make_cast_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_load_correct">make_load_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Constpropproof.html#make_mulimm_correct">make_mulimm_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_op_correct">make_op_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Constpropproof.html#make_orimm_correct">make_orimm_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Kildall.html#make_predecessors_correct">make_predecessors_correct</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Constpropproof.html#make_shlimm_correct">make_shlimm_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#make_shrimm_correct">make_shrimm_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#make_shruimm_correct">make_shruimm_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_stackaddr_correct">make_stackaddr_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#make_store_correct">make_store_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Constpropproof.html#make_xorimm_correct">make_xorimm_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.RTLtyping.html#mapped_included_consistent">mapped_included_consistent</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#mapped_list_included">mapped_list_included</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Alloctyping_aux.html#map_f_getsrc_getdst">map_f_getsrc_getdst</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#map_inv">map_inv</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.RTLgenproof1.html#map_wf_incr">map_wf_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_left">match_callstack_alloc_left</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_other">match_callstack_alloc_other</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_right">match_callstack_alloc_right</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_variables">match_callstack_alloc_variables</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_alloc_variables_rec">match_callstack_alloc_variables_rec</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_freelist">match_callstack_freelist</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_freelist_rec">match_callstack_freelist_rec</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_incr_bound">match_callstack_incr_bound</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_mapped">match_callstack_mapped</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_match_globalenvs">match_callstack_match_globalenvs</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_store_above">match_callstack_store_above</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_store_local">match_callstack_store_local</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack_store_local_unchanged">match_callstack_store_local_unchanged</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_alloc_other">match_env_alloc_other</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_alloc_same">match_env_alloc_same</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_empty">match_env_empty</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_exten">match_env_exten</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_extensional">match_env_extensional</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_find_reg">match_env_find_reg</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_freelist">match_env_freelist</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_invariant">match_env_invariant</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_letvar">match_env_letvar</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_store_above">match_env_store_above</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_store_local">match_env_store_local</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env_store_mapped">match_env_store_mapped</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_update_temp">match_env_update_temp</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env_update_var">match_env_update_var</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_globalenvs_init">match_globalenvs_init</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_init_env_init_reg">match_init_env_init_reg</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_set_locals">match_set_locals</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_set_params_init_regs">match_set_params_init_regs</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Linearizetyping.html#max_over_instrs_bound">max_over_instrs_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizetyping.html#max_over_list_bound">max_over_list_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_list_pos">max_over_list_pos</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#max_over_regs_of_funct_bound">max_over_regs_of_funct_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_regs_of_funct_pos">max_over_regs_of_funct_pos</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Linearizetyping.html#max_over_slots_of_funct_bound">max_over_slots_of_funct_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_slots_of_funct_pos">max_over_slots_of_funct_pos</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.RTLtyping.html#member_correct">member_correct</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Globalenvs.html#mem_add_globals_transf">mem_add_globals_transf</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="lib.Sets.html#mem_add_other">mem_add_other</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Sets.html#mem_add_same">mem_add_same</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.InterfGraph.html#mem_add_tail">mem_add_tail</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="lib.Sets.html#mem_empty">mem_empty</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Mem.html#mem_exten">mem_exten</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Sets.html#mem_remove_other">mem_remove_other</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Sets.html#mem_remove_same">mem_remove_same</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Sets.html#mem_union">mem_union</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Integers.html#mkint_eq">mkint_eq</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#mods_divs">mods_divs</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mods_divs">mods_divs</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#modulus_pos">modulus_pos</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#modu_and">modu_and</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#modu_divu">modu_divu</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#modu_divu">modu_divu</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#modu_divu_Euclid">modu_divu_Euclid</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#modu_pow2">modu_pow2</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mod_in_range">mod_in_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#mone_max_unsigned">mone_max_unsigned</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Alloctyping_aux.html#move_types_res">move_types_res</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Alloctyping_aux.html#move_types_stepf">move_types_stepf</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Locations.html#mreg_eq">mreg_eq</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Linearizetyping.html#mreg_is_bounded">mreg_is_bounded</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Kildall.html#multiple_predecessors">multiple_predecessors</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="lib.Integers.html#mul_add_distr_l">mul_add_distr_l</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mul_add_distr_l">mul_add_distr_l</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mul_add_distr_r">mul_add_distr_r</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mul_add_distr_r">mul_add_distr_r</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mul_assoc">mul_assoc</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mul_assoc">mul_assoc</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#mul_commut">mul_commut</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mul_commut">mul_commut</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#mul_one">mul_one</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#mul_pow2">mul_pow2</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#mul_pow2">mul_pow2</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#mul_zero">mul_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLgenproof1.html#mutated_reg_in_map">mutated_reg_in_map</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<br/><br/><a name="lemma_N"></a><h2>N </h2>
-<a href="backend.Values.html#negate_cmp">negate_cmp</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#negate_cmp">negate_cmp</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#negate_cmpf_eq">negate_cmpf_eq</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#negate_cmpu">negate_cmpu</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#negate_cmpu">negate_cmpu</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#negate_cmp_mismatch">negate_cmp_mismatch</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#neg_add_distr">neg_add_distr</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#neg_add_distr">neg_add_distr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#neg_repr">neg_repr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#neg_zero">neg_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#neg_zero">neg_zero</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Parallelmove.html#neq_is_neq">neq_is_neq</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_fresh">new_reg_fresh</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_incr">new_reg_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_not_in_map">new_reg_not_in_map</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_not_mutated">new_reg_not_mutated</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_return_ok">new_reg_return_ok</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#new_reg_valid">new_reg_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#nextinstr_inv">nextinstr_inv</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#nextinstr_set_preg">nextinstr_set_preg</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Locations.html#non_overlap_diff">non_overlap_diff</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlapaux_insert">noOverlapaux_insert</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlapaux_swap2">noOverlapaux_swap2</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_auxpop">noOverlap_auxpop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_auxPop">noOverlap_auxPop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_aux_app">noOverlap_aux_app</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_Front0">noOverlap_Front0</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_head">noOverlap_head</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_insert">noOverlap_insert</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_movBack">noOverlap_movBack</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_movBack0">noOverlap_movBack0</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_movFront">noOverlap_movFront</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_nil">noOverlap_nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_Pop">noOverlap_Pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_pop">noOverlap_pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_right">noOverlap_right</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_swap">noOverlap_swap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noO_diff">noO_diff</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#noO_list_pnilnil">noO_list_pnilnil</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#noRead_app">noRead_app</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noRead_by_path">noRead_by_path</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#norepet_SD">norepet_SD</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Values.html#notbool_idem2">notbool_idem2</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#notbool_idem3">notbool_idem3</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#notbool_isfalse_istrue">notbool_isfalse_istrue</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#notbool_istrue_isfalse">notbool_istrue_isfalse</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#notbool_is_bool">notbool_is_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#notbool_negb_1">notbool_negb_1</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#notbool_negb_2">notbool_negb_2</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#notbool_xor">notbool_xor</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Parallelmove.html#notindst_nW">notindst_nW</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#notin_disjoint">notin_disjoint</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#notin_not_in">notin_not_in</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_lastnoTmp">noTmpLast_lastnoTmp</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_Pop">noTmpLast_Pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_pop">noTmpLast_pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_popBack">noTmpLast_popBack</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_push">noTmpLast_push</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast_tmpLast">noTmpLast_tmpLast</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpL_diff">noTmpL_diff</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_app">noTmp_app</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_append">noTmp_append</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmP_noOverlap_aux">noTmP_noOverlap_aux</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_noReadTmp">noTmp_noReadTmp</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_noTmpLast">noTmp_noTmpLast</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp_pop">noTmp_pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_in">noWrite_in</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_insert">noWrite_insert</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_movFront">noWrite_movFront</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_pop">noWrite_pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_swap">noWrite_swap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite_tmpLast">noWrite_tmpLast</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlapD_inv">no_overlapD_inv</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlapD_invf">no_overlapD_invf</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlapD_invpp">no_overlapD_invpp</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlapD_res">no_overlapD_res</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Conventions.html#no_overlap_arguments">no_overlap_arguments</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlap_list_pop">no_overlap_list_pop</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#no_overlap_noOverlap">no_overlap_noOverlap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Conventions.html#no_overlap_parameters">no_overlap_parameters</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlap_temp">no_overlap_temp</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Kildall.html#no_self_loop">no_self_loop</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="lib.Coqlib.html#nth_error_in">nth_error_in</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#nth_error_nil">nth_error_nil</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.CSEproof.html#numbering_holds_exten">numbering_holds_exten</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<br/><br/><a name="lemma_O"></a><h2>O </h2>
-<a href="backend.Stackingproof.html#offset_of_index_disj">offset_of_index_disj</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#offset_of_index_no_overflow">offset_of_index_no_overflow</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#offset_of_index_valid">offset_of_index_valid</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Values.html#of_bool_is_bool">of_bool_is_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#one_bits_decomp">one_bits_decomp</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#one_bits_range">one_bits_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#one_not_zero">one_not_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.union_find.html#option_sum">option_sum</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.Constpropproof.html#op_strength_reduction_correct">op_strength_reduction_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.InterfGraph.html#ordered_pair_charact">ordered_pair_charact</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#ordered_pair_sym">ordered_pair_sym</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.PPCgenproof1.html#orimm_correct">orimm_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="lib.Integers.html#or_assoc">or_assoc</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or_assoc">or_assoc</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#or_commut">or_commut</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or_commut">or_commut</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#or_idem">or_idem</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#or_mone">or_mone</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or_of_bool">or_of_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#or_rolm">or_rolm</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or_rolm">or_rolm</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#or_zero">or_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Linearizetyping.html#outgoing_slot_bound">outgoing_slot_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Locations.html#overlap_aux_false_1">overlap_aux_false_1</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#overlap_aux_true_1">overlap_aux_true_1</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#overlap_aux_true_2">overlap_aux_true_2</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#overlap_not_diff">overlap_not_diff</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<br/><br/><a name="lemma_P"></a><h2>P </h2>
-<a href="backend.Allocproof.html#parallel_move_correct">parallel_move_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof_aux.html#parallel_move_correctX">parallel_move_correctX</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#parallel_move_correct'">parallel_move_correct'</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#path_pop">path_pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#path_tmpLast">path_tmpLast</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Coqlib.html#peq_false">peq_false</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#peq_true">peq_true</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_add">pexec_add</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_correct">pexec_correct</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_mov">pexec_mov</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_movBack">pexec_movBack</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_movFront">pexec_movFront</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_nop">pexec_nop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_push">pexec_push</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_swap">pexec_swap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#pexec_update">pexec_update</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Coqlib.html#Ple_refl">Ple_refl</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Ple_succ">Ple_succ</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Ple_trans">Ple_trans</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_ne">Plt_ne</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_Ple">Plt_Ple</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_Ple_trans">Plt_Ple_trans</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_strict">Plt_strict</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_succ">Plt_succ</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_succ_inv">Plt_succ_inv</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_trans">Plt_trans</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_trans_succ">Plt_trans_succ</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt_wf">Plt_wf</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Parallelmove.html#Pmov_equation">Pmov_equation</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Coqlib.html#positive_Peano_ind">positive_Peano_ind</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#positive_rec_base">positive_rec_base</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#positive_rec_succ">positive_rec_succ</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Ppred_Plt">Ppred_Plt</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Kildall.html#predecessors_correct">predecessors_correct</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.PPC.html#preg_eq">preg_eq</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of_injective">preg_of_injective</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of_is_data_reg">preg_of_is_data_reg</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of_not">preg_of_not</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of_not_GPR1">preg_of_not_GPR1</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_val">preg_val</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Tunnelingtyping.html#program_typing_preserved">program_typing_preserved</a> [in <a href="backend.Tunnelingtyping.html">backend.Tunnelingtyping</a>]<br/>
-<a href="backend.Linearizetyping.html#program_typing_preserved">program_typing_preserved</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Alloctyping.html#program_typing_preserved">program_typing_preserved</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#program_typing_preserved">program_typing_preserved</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Globalenvs.html#prog_funct_transf_OK">prog_funct_transf_OK</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors_charact1">propagate_successors_charact1</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors_charact2">propagate_successors_charact2</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors_invariant">propagate_successors_invariant</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors_P">propagate_successors_P</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_charact">propagate_succ_charact</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_incr">propagate_succ_incr</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_incr_worklist">propagate_succ_incr_worklist</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list_charact">propagate_succ_list_charact</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list_incr">propagate_succ_list_incr</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list_incr_worklist">propagate_succ_list_incr_worklist</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list_records_changes">propagate_succ_list_records_changes</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_records_changes">propagate_succ_records_changes</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<br/><br/><a name="lemma_R"></a><h2>R </h2>
-<a href="backend.Linearizeproof.html#reachable_correct_1">reachable_correct_1</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#reachable_correct_2">reachable_correct_2</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#reachable_entrypoint">reachable_entrypoint</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#reachable_successors">reachable_successors</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Parallelmove.html#rebuild_l">rebuild_l</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.CSE.html#refl_ge">refl_ge</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_acceptable">regalloc_acceptable</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_correct_1">regalloc_correct_1</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_correct_2">regalloc_correct_2</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_correct_3">regalloc_correct_3</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_disj_temporaries">regalloc_disj_temporaries</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_norepet_norepet">regalloc_norepet_norepet</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_noteq_diff">regalloc_noteq_diff</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_notin_notin">regalloc_notin_notin</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#regalloc_not_temporary">regalloc_not_temporary</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_ok">regalloc_ok</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#regalloc_preserves_types">regalloc_preserves_types</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Conventions.html#register_classification">register_classification</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Coloringproof.html#regsalloc_acceptable">regsalloc_acceptable</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Constpropproof.html#regs_match_approx_increasing">regs_match_approx_increasing</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#regs_match_approx_update">regs_match_approx_update</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Allocproof.html#reg_for_spec">reg_for_spec</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_fresh_decr">reg_fresh_decr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_in_map_valid">reg_in_map_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_valid_incr">reg_valid_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.CSEproof.html#reg_valnum_correct">reg_valnum_correct</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.Inclusion.html#remove_all_leaves_sound">remove_all_leaves_sound</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.RTLtyping.html#repet_correct">repet_correct</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#replace_last_id">replace_last_id</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.union_find.html#repr_aux_canon">repr_aux_canon</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_aux_none">repr_aux_none</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_aux_some">repr_aux_some</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_empty">repr_empty</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_rec_ext">repr_rec_ext</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_repr">repr_repr</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.Integers.html#repr_signed">repr_signed</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#repr_unsigned">repr_unsigned</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLgenproof1.html#reserve_instr_incr">reserve_instr_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#reserve_instr_wf">reserve_instr_wf</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Stackingproof.html#restore_callee_save_correct">restore_callee_save_correct</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#restore_float_callee_save_correct">restore_float_callee_save_correct</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#restore_float_callee_save_correct_rec">restore_float_callee_save_correct_rec</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#restore_int_callee_save_correct">restore_int_callee_save_correct</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#restore_int_callee_save_correct_rec">restore_int_callee_save_correct_rec</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Allocproof.html#return_regs_not_destroyed">return_regs_not_destroyed</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#return_regs_result">return_regs_result</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#return_reg_ok_incr">return_reg_ok_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="lib.Maps.html#rleaf">rleaf</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Integers.html#rolm_rolm">rolm_rolm</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#rolm_rolm">rolm_rolm</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#rolm_zero">rolm_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#rolm_zero">rolm_zero</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#rol_and">rol_and</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rol_or">rol_or</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rol_rol">rol_rol</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rol_zero">rol_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<br/><br/><a name="lemma_S"></a><h2>S </h2>
-<a href="lib.union_find.html#sameclass_empty">sameclass_empty</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_identify_1">sameclass_identify_1</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_identify_2">sameclass_identify_2</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_refl">sameclass_refl</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_repr">sameclass_repr</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_sym">sameclass_sym</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass_trans">sameclass_trans</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.Parallelmove.html#sameExec_reflexive">sameExec_reflexive</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#sameExec_transitive">sameExec_transitive</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#same_not_diff">same_not_diff</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Coloringproof.html#same_typ_correct">same_typ_correct</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Stackingproof.html#save_callee_save_correct">save_callee_save_correct</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#save_float_callee_save_correct">save_float_callee_save_correct</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#save_float_callee_save_correct_rec">save_float_callee_save_correct_rec</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#save_int_callee_save_correct">save_int_callee_save_correct</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#save_int_callee_save_correct_rec">save_int_callee_save_correct_rec</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Parallelmove.html#SB_Pmov">SB_Pmov</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#SDone_Pmov">SDone_Pmov</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#SDone_stepf">SDone_stepf</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#sD_nW">sD_nW</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#sD_pexec">sD_pexec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Mem.html#setN_agree">setN_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#setN_inject">setN_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#setN_outside_agree">setN_outside_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#setN_outside_inject">setN_outside_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_agree">set_cont_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_inject">set_cont_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_inside">set_cont_inside</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_outside">set_cont_outside</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_outside1">set_cont_outside1</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_outside_agree">set_cont_outside_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont_outside_inject">set_cont_outside_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#set_locals_defined">set_locals_defined</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#set_locals_params_defined">set_locals_params_defined</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#set_params_defined">set_params_defined</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#set_slot_index">set_slot_index</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Machtyping.html#set_slot_link_invariant">set_slot_link_invariant</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Stackingproof.html#set_slot_ok">set_slot_ok</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#shift_eval_addressing">shift_eval_addressing</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#shift_eval_operation">shift_eval_operation</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Values.html#shl_mul">shl_mul</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shl_mul">shl_mul</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shl_mul_two_p">shl_mul_two_p</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shl_rolm">shl_rolm</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shl_rolm">shl_rolm</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shl_zero">shl_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shru_div_two_p">shru_div_two_p</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shru_rolm">shru_rolm</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shru_rolm">shru_rolm</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shru_zero">shru_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shrx_carry">shrx_carry</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shrx_carry">shrx_carry</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#shr_zero">shr_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#signed_range">signed_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#signed_repr">signed_repr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Allocproof.html#sig_function_translated">sig_function_translated</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#sig_transl_function">sig_transl_function</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_insert">simpleDest_insert</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_movBack">simpleDest_movBack</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_movFront">simpleDest_movFront</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_Pop">simpleDest_Pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_pop">simpleDest_pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_pop2">simpleDest_pop2</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_right">simpleDest_right</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_swap">simpleDest_swap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_swap_app">simpleDest_swap_app</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest_tmpLast">simpleDest_tmpLast</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Linearizetyping.html#size_arguments_bound">size_arguments_bound</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Mem.html#size_chunk_pos">size_chunk_pos</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#size_mem_pos">size_mem_pos</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Stackingproof.html#size_no_overflow">size_no_overflow</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#size_pos">size_pos</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Locations.html#slot_eq">slot_eq</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Stackingproof.html#slot_gi">slot_gi</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#slot_gso">slot_gso</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#slot_gss">slot_gss</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#slot_iso">slot_iso</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#slot_iss">slot_iss</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Linearizetyping.html#slot_is_bounded">slot_is_bounded</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="lib.Inclusion.html#sort_included">sort_included</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#sort_included2">sort_included2</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Parallelmove.html#splitNone">splitNone</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#splitSome">splitSome</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#split_length">split_length</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Alloctyping_aux.html#split_move_incl">split_move_incl</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.PPCgenproof1.html#sp_val">sp_val</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Alloctyping_aux.html#srcdst_tmp2_stepf">srcdst_tmp2_stepf</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Alloctyping_aux.html#src_tmp2_res">src_tmp2_res</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Linearizeproof.html#starts_with_correct">starts_with_correct</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Kildall.html#start_state_good">start_state_good</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#start_state_in_entry">start_state_in_entry</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_extends">state_incr_extends</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_refl">state_incr_refl</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans">state_incr_trans</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans2">state_incr_trans2</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans3">state_incr_trans3</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans4">state_incr_trans4</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans5">state_incr_trans5</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_trans6">state_incr_trans6</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Parallelmove.html#stepf1_dec">stepf1_dec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_dec">stepf_dec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_dec0">stepf_dec0</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_dec0'">stepf_dec0'</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_pop">stepf_pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf_popLoop">stepf_popLoop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#stepInv_pnilnil">stepInv_pnilnil</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_inv">stepp_inv</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_sameExec">stepp_sameExec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_transitive">stepp_transitive</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLtyping.html#step1">step1</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#step2">step2</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#step3">step3</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#step4">step4</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#step_dec">step_dec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_dec0">step_dec0</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv">step_inv</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_getdst">step_inv_getdst</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_loop">step_inv_loop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_loop_aux">step_inv_loop_aux</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_noOverlap">step_inv_noOverlap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_NoOverlap">step_inv_NoOverlap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_noTmp">step_inv_noTmp</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_noTmpLast">step_inv_noTmpLast</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_path">step_inv_path</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_inv_simpleDest">step_inv_simpleDest</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_sameExec">step_sameExec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Kildall.html#step_state_good">step_state_good</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#step_stepp">step_stepp</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLgenproof1.html#stmt_stmtlist_ind">stmt_stmtlist_ind</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Parallelmove.html#STM_Pmov">STM_Pmov</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.PPCgenproof1.html#storeind_aux_correct">storeind_aux_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#storeind_correct">storeind_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Mem.html#storev_mapped_inject">storev_mapped_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#storev_mapped_inject_1">storev_mapped_inject_1</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgenproof.html#storev_16_signed_unsigned">storev_16_signed_unsigned</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.PPCgenproof.html#storev_8_signed_unsigned">storev_8_signed_unsigned</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Mem.html#store_agree">store_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_alloc">store_alloc</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_contentmap_agree">store_contentmap_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_contentmap_outside_agree">store_contentmap_outside_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_contents_inject">store_contents_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_contents_outside_inject">store_contents_outside_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_inv">store_inv</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_in_bounds">store_in_bounds</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_is_in_bounds">store_is_in_bounds</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_mapped_inject">store_mapped_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_mapped_inject_1">store_mapped_inject_1</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_outside_agree">store_outside_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_outside_extends">store_outside_extends</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#store_parameters_correct">store_parameters_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#store_unmapped_inject">store_unmapped_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#store_within_extends">store_within_extends</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Machtyping.html#subject_reduction">subject_reduction</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#subject_reduction">subject_reduction</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Machtyping.html#subject_reduction_function">subject_reduction_function</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#subject_reduction_instr">subject_reduction_instr</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#subject_reduction_instrs">subject_reduction_instrs</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Values.html#sub_add_l">sub_add_l</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#sub_add_l">sub_add_l</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#sub_add_opp">sub_add_opp</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#sub_add_opp">sub_add_opp</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#sub_add_r">sub_add_r</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#sub_add_r">sub_add_r</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#sub_idem">sub_idem</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#sub_shifted">sub_shifted</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#sub_zero_l">sub_zero_l</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#sub_zero_r">sub_zero_r</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#sub_zero_r">sub_zero_r</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.LTL.html#successors_aux_invariant">successors_aux_invariant</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#successors_correct">successors_correct</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.RTL.html#successors_correct">successors_correct</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="lib.Integers.html#swap_cmp">swap_cmp</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#swap_cmp">swap_cmp</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#swap_cmpu">swap_cmpu</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#swap_cmpu">swap_cmpu</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#swap_cmp_mismatch">swap_cmp_mismatch</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Globalenvs.html#symbols_add_globals_transf">symbols_add_globals_transf</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#symbols_init_transf">symbols_init_transf</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Tunnelingproof.html#symbols_preserved">symbols_preserved</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Allocproof.html#symbols_preserved">symbols_preserved</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#symbols_preserved">symbols_preserved</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Constpropproof.html#symbols_preserved">symbols_preserved</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.PPCgenproof.html#symbols_preserved">symbols_preserved</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#symbols_preserved">symbols_preserved</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Linearizeproof.html#symbols_preserved">symbols_preserved</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.CSEproof.html#symbols_preserved">symbols_preserved</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Stackingproof.html#symbols_preserved">symbols_preserved</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<br/><br/><a name="lemma_T"></a><h2>T </h2>
-<a href="backend.RTLgenproof1.html#target_regs_not_mutated">target_regs_not_mutated</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_regs_ok_incr">target_regs_ok_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_regs_valid">target_regs_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_not_mutated">target_reg_not_mutated</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_ok_incr">target_reg_ok_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_valid">target_reg_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Conventions.html#temporaries_not_acceptable">temporaries_not_acceptable</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.RTLtyping.html#teq_correct">teq_correct</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Inclusion.html#test_inclusion_sound">test_inclusion_sound</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.CSE.html#top_ge">top_ge</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Constpropproof.html#transfer_correct">transfer_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.CSEproof.html#transfer_correct">transfer_correct</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Main.html#transform_partial_program_compose">transform_partial_program_compose</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.AST.html#transform_partial_program_function">transform_partial_program_function</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#transform_partial_program_main">transform_partial_program_main</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#transform_program_function">transform_program_function</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Main.html#transform_program_partial_total">transform_program_partial_total</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Globalenvs.html#transform_program_transform_partial_program">transform_program_transform_partial_program</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program2_correct">transf_cminor_program2_correct</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program_correct">transf_cminor_program_correct</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program_equiv">transf_cminor_program_equiv</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.CSE.html#transf_code_wf">transf_code_wf</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Constprop.html#transf_code_wf">transf_code_wf</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.RTL.html#transf_code_wf">transf_code_wf</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program2_correct">transf_csharpminor_program2_correct</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program_correct">transf_csharpminor_program_correct</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program_equiv">transf_csharpminor_program_equiv</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Allocproof.html#transf_entrypoint_correct">transf_entrypoint_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocation.html#transf_entrypoint_wf">transf_entrypoint_wf</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Linearizeproof.html#transf_function_correct">transf_function_correct</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.PPCgenproof.html#transf_function_correct">transf_function_correct</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#transf_function_correct">transf_function_correct</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.CSEproof.html#transf_function_correct">transf_function_correct</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Constpropproof.html#transf_funct_correct">transf_funct_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Main.html#transf_partial_program_compose">transf_partial_program_compose</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Linearizeproof.html#transf_program_correct">transf_program_correct</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#transf_program_correct">transf_program_correct</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Constpropproof.html#transf_program_correct">transf_program_correct</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.PPCgenproof.html#transf_program_correct">transf_program_correct</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.CSEproof.html#transf_program_correct">transf_program_correct</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Main.html#transf_program_partial_total">transf_program_partial_total</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Globalenvs.html#transf_program_transf_partial_program">transf_program_transf_partial_program</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="lib.Integers.html#translate_cmp">translate_cmp</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#translate_eq">translate_eq</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#translate_lt">translate_lt</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.PPCgenproof.html#transl_code_label">transl_code_label</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_CEcondition_correct">transl_condition_CEcondition_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_CEcond_correct">transl_condition_CEcond_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_CEfalse_correct">transl_condition_CEfalse_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_CEtrue_correct">transl_condition_CEtrue_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_condition_incr">transl_condition_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_cond_correct">transl_cond_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_cond_correct_aux">transl_cond_correct_aux</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_exprlist_Econs_correct">transl_exprlist_Econs_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_exprlist_Econs_correct">transl_exprlist_Econs_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_exprlist_Enil_correct">transl_exprlist_Enil_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_exprlist_Enil_correct">transl_exprlist_Enil_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_exprlist_incr">transl_exprlist_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_expr_condition_exprlist_incr">transl_expr_condition_exprlist_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eaddrof_global_correct">transl_expr_Eaddrof_global_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eaddrof_local_correct">transl_expr_Eaddrof_local_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eassign_correct">transl_expr_Eassign_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Eassign_correct">transl_expr_Eassign_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Ecall_correct">transl_expr_Ecall_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Ecall_correct">transl_expr_Ecall_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Econdition_correct">transl_expr_Econdition_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Econdition_false_correct">transl_expr_Econdition_false_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Econdition_true_correct">transl_expr_Econdition_true_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Eletvar_correct">transl_expr_Eletvar_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eletvar_correct">transl_expr_Eletvar_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Elet_correct">transl_expr_Elet_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Elet_correct">transl_expr_Elet_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Eload_correct">transl_expr_Eload_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eload_correct">transl_expr_Eload_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Eop_correct">transl_expr_Eop_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Eop_correct">transl_expr_Eop_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Estore_correct">transl_expr_Estore_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Estore_correct">transl_expr_Estore_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_expr_Evar_correct">transl_expr_Evar_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_Evar_correct">transl_expr_Evar_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_expr_incr">transl_expr_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof.html#transl_find_label">transl_find_label</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#transl_find_label">transl_find_label</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_funcall_correct">transl_funcall_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_funcall_correct">transl_funcall_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_function_correct">transl_function_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_function_correct">transl_function_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_function_correctness">transl_function_correctness</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_function_correctness">transl_function_correctness</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Icall_correct">transl_Icall_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Icond_false_correct">transl_Icond_false_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Icond_true_correct">transl_Icond_true_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Iload_correct">transl_Iload_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Inop_correct">transl_Inop_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof.html#transl_instr_label">transl_instr_label</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Iop_correct">transl_Iop_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_Istore_correct">transl_Istore_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_load_correct">transl_load_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_load_store_correct">transl_load_store_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#transl_one_correct">transl_one_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_op_correct">transl_op_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_program_correct">transl_program_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Stackingproof.html#transl_program_correct">transl_program_correct</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_program_correct">transl_program_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_program_correct">transl_program_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Allocproof.html#transl_refl_correct">transl_refl_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmtlist_incr">transl_stmtlist_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmtlist_Scons_continue_correct">transl_stmtlist_Scons_continue_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmtlist_Scons_stop_correct">transl_stmtlist_Scons_stop_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmtlist_Scons_1_correct">transl_stmtlist_Scons_1_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmtlist_Scons_2_correct">transl_stmtlist_Scons_2_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmtlist_Snil_correct">transl_stmtlist_Snil_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmtlist_Snil_correct">transl_stmtlist_Snil_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmt_incr">transl_stmt_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sblock_correct">transl_stmt_Sblock_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sblock_correct">transl_stmt_Sblock_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sexit_correct">transl_stmt_Sexit_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sexit_correct">transl_stmt_Sexit_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sexpr_correct">transl_stmt_Sexpr_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sexpr_correct">transl_stmt_Sexpr_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sifthenelse_correct">transl_stmt_Sifthenelse_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sifthenelse_false_correct">transl_stmt_Sifthenelse_false_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sifthenelse_true_correct">transl_stmt_Sifthenelse_true_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sloop_exit_correct">transl_stmt_Sloop_exit_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sloop_loop_correct">transl_stmt_Sloop_loop_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sloop_loop_correct">transl_stmt_Sloop_loop_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sloop_stop_correct">transl_stmt_Sloop_stop_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sreturn_none_correct">transl_stmt_Sreturn_none_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sreturn_none_correct">transl_stmt_Sreturn_none_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_Sreturn_some_correct">transl_stmt_Sreturn_some_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#transl_stmt_Sreturn_some_correct">transl_stmt_Sreturn_some_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmt_stmtlist_incr">transl_stmt_stmtlist_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#transl_store_correct">transl_store_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Allocproof.html#transl_trans_correct">transl_trans_correct</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#tunnel_function_correct">tunnel_function_correct</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="lib.Coqlib.html#two_power_nat_O">two_power_nat_O</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#two_power_nat_pos">two_power_nat_pos</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Locations.html#typesize_pos">typesize_pos</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_complete">type_args_complete</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_correct">type_args_correct</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_extends">type_args_extends</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_included">type_args_included</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_mapped">type_args_mapped</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_res_complete">type_args_res_complete</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_res_included">type_args_res_included</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_args_res_ros_included">type_args_res_ros_included</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_complete">type_arg_complete</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_correct">type_arg_correct</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_correct_1">type_arg_correct_1</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_extends">type_arg_extends</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_included">type_arg_included</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_arg_mapped">type_arg_mapped</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_instrs_extends">type_instrs_extends</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_instrs_included">type_instrs_included</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_instr_included">type_instr_included</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Op.html#type_of_chunk_correct">type_of_chunk_correct</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#type_of_operation_sound">type_of_operation_sound</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.RTLtyping.html#type_res_complete">type_res_complete</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_res_correct">type_res_correct</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_ros_complete">type_ros_complete</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_ros_correct">type_ros_correct</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function_correct">type_rtl_function_correct</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function_instrs">type_rtl_function_instrs</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function_norepet">type_rtl_function_norepet</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function_params">type_rtl_function_params</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Alloctyping_aux.html#T_type">T_type</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<br/><br/><a name="lemma_U"></a><h2>U </h2>
-<a href="backend.Values.html#undef_is_bool">undef_is_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Stackingproof.html#unfold_transf_function">unfold_transf_function</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#unique_labels_lin_block">unique_labels_lin_block</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#unique_labels_lin_function">unique_labels_lin_function</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#unique_labels_lin_rec">unique_labels_lin_rec</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="lib.Coqlib.html#unroll_positive_rec">unroll_positive_rec</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#unsigned_range">unsigned_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#unsigned_range_2">unsigned_range_2</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#unsigned_repr">unsigned_repr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Parallelmove.html#unsplit_move">unsplit_move</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLgenproof1.html#update_instr_extends">update_instr_extends</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#update_instr_incr">update_instr_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#update_instr_wf">update_instr_wf</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Mem.html#update_o">update_o</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#update_s">update_s</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<br/><br/><a name="lemma_V"></a><h2>V </h2>
-<a href="backend.Mem.html#valid_block_alloc">valid_block_alloc</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#valid_block_free">valid_block_free</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#valid_block_store">valid_block_store</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.RTLgenproof1.html#valid_fresh_absurd">valid_fresh_absurd</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#valid_fresh_different">valid_fresh_different</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Mem.html#valid_new_block">valid_new_block</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#valid_not_valid_diff">valid_not_valid_diff</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#valid_pointer_inject_no_overflow">valid_pointer_inject_no_overflow</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.CSEproof.html#valnum_regs_holds">valnum_regs_holds</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#valnum_reg_holds">valnum_reg_holds</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#valu_agree_list">valu_agree_list</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#valu_agree_refl">valu_agree_refl</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#valu_agree_trans">valu_agree_trans</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#val_content_inject_cast">val_content_inject_cast</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#val_content_inject_incr">val_content_inject_incr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject_incr">val_inject_incr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_list_inject_incr">val_list_inject_incr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Constpropproof.html#val_match_approx_increasing">val_match_approx_increasing</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_match_extensional">vars_vals_match_extensional</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_match_holds">vars_vals_match_holds</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_match_holds_1">vars_vals_match_holds_1</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#var_addr_global_correct">var_addr_global_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#var_addr_local_correct">var_addr_local_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#var_get_correct">var_get_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#var_set_correct">var_set_correct</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<br/><br/><a name="lemma_W"></a><h2>W </h2>
-<a href="backend.CSEproof.html#wf_add_load">wf_add_load</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_add_op">wf_add_op</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_add_rhs">wf_add_rhs</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_analyze">wf_analyze</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.union_find.html#wf_empty">wf_empty</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.CSEproof.html#wf_empty_numbering">wf_empty_numbering</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_equation_increasing">wf_equation_increasing</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_kill_loads">wf_kill_loads</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_rhs_increasing">wf_rhs_increasing</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_transfer">wf_transfer</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Tunneling.html#wf_tunneled_code">wf_tunneled_code</a> [in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.CSEproof.html#wf_valnum_reg">wf_valnum_reg</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_valnum_regs">wf_valnum_regs</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_call">wt_add_call</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_cond">wt_add_cond</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_entry">wt_add_entry</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_load">wt_add_load</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_move">wt_add_move</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping_aux.html#wt_add_moves">wt_add_moves</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_op_move">wt_add_op_move</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_op_others">wt_add_op_others</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_op_undef">wt_add_op_undef</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_reload">wt_add_reload</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_reloads">wt_add_reloads</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_return">wt_add_return</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_spill">wt_add_spill</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_store">wt_add_store</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_add_undefs">wt_add_undefs</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_fold_right">wt_fold_right</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_get_slot">wt_get_slot</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_init_frame">wt_init_frame</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_init_regs">wt_init_regs</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_instrs_cons">wt_instrs_cons</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Linearizetyping.html#wt_linearize_block">wt_linearize_block</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Linearizetyping.html#wt_linearize_body">wt_linearize_body</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_Msetstack'">wt_Msetstack'</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_parallel_move">wt_parallel_move</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping_aux.html#wt_parallel_moveX">wt_parallel_moveX</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.Alloctyping_aux.html#wt_parallel_move'">wt_parallel_move'</a> [in <a href="backend.Alloctyping_aux.html">backend.Alloctyping_aux</a>]<br/>
-<a href="backend.RTLtyping.html#wt_regset_assign">wt_regset_assign</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_regset_list">wt_regset_list</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_regs_for">wt_regs_for</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_regs_for_rec">wt_regs_for_rec</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_reg_for">wt_reg_for</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_restore_callee_save">wt_restore_callee_save</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_restore_float_callee_save">wt_restore_float_callee_save</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_restore_int_callee_save">wt_restore_int_callee_save</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_rtl_function">wt_rtl_function</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_save_callee_save">wt_save_callee_save</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_save_float_callee_save">wt_save_float_callee_save</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_save_int_callee_save">wt_save_int_callee_save</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_setreg">wt_setreg</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_set_slot">wt_set_slot</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_transf_entrypoint">wt_transf_entrypoint</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_transf_function">wt_transf_function</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_transf_function">wt_transf_function</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Linearizetyping.html#wt_transf_function">wt_transf_function</a> [in <a href="backend.Linearizetyping.html">backend.Linearizetyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_transf_instr">wt_transf_instr</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#wt_transf_instrs">wt_transf_instrs</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_transl_instr">wt_transl_instr</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Tunnelingtyping.html#wt_tunnel_block">wt_tunnel_block</a> [in <a href="backend.Tunnelingtyping.html">backend.Tunnelingtyping</a>]<br/>
-<a href="backend.Tunnelingtyping.html#wt_tunnel_function">wt_tunnel_function</a> [in <a href="backend.Tunnelingtyping.html">backend.Tunnelingtyping</a>]<br/>
-<br/><br/><a name="lemma_X"></a><h2>X </h2>
-<a href="lib.Maps.html#xcombine_lr">xcombine_lr</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_complete">xelements_complete</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_correct">xelements_correct</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_hi">xelements_hi</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_ho">xelements_ho</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_ih">xelements_ih</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_ii">xelements_ii</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_io">xelements_io</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_keys_norepet">xelements_keys_norepet</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_oh">xelements_oh</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_oi">xelements_oi</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements_oo">xelements_oo</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xgcombine">xgcombine</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xgcombine_l">xgcombine_l</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xgcombine_r">xgcombine_r</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xget_left">xget_left</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xgmap">xgmap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.PPCgenproof1.html#xorimm_correct">xorimm_correct</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="lib.Integers.html#xor_assoc">xor_assoc</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#xor_assoc">xor_assoc</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#xor_commut">xor_commut</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#xor_commut">xor_commut</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#xor_one_one">xor_one_one</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#xor_zero">xor_zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#xor_zero_one">xor_zero_one</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<br/><br/><a name="lemma_Z"></a><h2>Z </h2>
-<a href="lib.Coqlib.html#Zdiv_small">Zdiv_small</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zdiv_unique">Zdiv_unique</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zeq_false">zeq_false</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zeq_true">zeq_true</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zle_false">zle_false</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zle_true">zle_true</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zlt_false">zlt_false</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zlt_true">zlt_true</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmax_bound_l">Zmax_bound_l</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmax_bound_r">Zmax_bound_r</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmax_spec">Zmax_spec</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmin_spec">Zmin_spec</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmod_small">Zmod_small</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Zmod_unique">Zmod_unique</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#Z_bin_decomp_range">Z_bin_decomp_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_bin_decomp_shift_add">Z_bin_decomp_shift_add</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_excl">Z_of_bits_excl</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_exten">Z_of_bits_exten</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_of_Z">Z_of_bits_of_Z</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_range">Z_of_bits_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_range_2">Z_of_bits_range_2</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_shift">Z_of_bits_shift</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_shifts">Z_of_bits_shifts</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_shifts_rev">Z_of_bits_shifts_rev</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits_shift_rev">Z_of_bits_shift_rev</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_one_bits_powerserie">Z_one_bits_powerserie</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_one_bits_range">Z_one_bits_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_shift_add_bin_decomp">Z_shift_add_bin_decomp</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_shift_add_inj">Z_shift_add_inj</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<br/><br/><hr/>
-<h1>Constructor Index</h1>
-<a name="constructor_A"></a><h2>A </h2>
-<a href="backend.Op.html#Abased">Abased</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstr.html#addf_case1">addf_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addf_case2">addf_case2</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addf_default">addf_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_case1">addimm_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_case2">addimm_case2</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_case3">addimm_case3</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_case4">addimm_case4</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_default">addimm_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case1">addressing_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case2">addressing_case2</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case3">addressing_case3</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case4">addressing_case4</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_case5">addressing_case5</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_default">addressing_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_case1">addr_strength_reduction_case1</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_case2">addr_strength_reduction_case2</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_case3">addr_strength_reduction_case3</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_default">addr_strength_reduction_default</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cmconstr.html#add_case1">add_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_case2">add_case2</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_case3">add_case3</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_case4">add_case4</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_case5">add_case5</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_default">add_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Op.html#Aglobal">Aglobal</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Aindexed">Aindexed</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Aindexed2">Aindexed2</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ainstack">Ainstack</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#alloc_variables_cons">alloc_variables_cons</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#alloc_variables_nil">alloc_variables_nil</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<br/><br/><a name="constructor_B"></a><h2>B </h2>
-<a href="backend.LTL.html#Bcall">Bcall</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bcond">Bcond</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bgetstack">Bgetstack</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bgoto">Bgoto</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Csharpminor.html#bind_parameters_cons">bind_parameters_cons</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#bind_parameters_nil">bind_parameters_nil</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.LTL.html#Bload">Bload</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Values.html#bool_of_val_int_true">bool_of_val_int_true</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.LTL.html#Bop">Bop</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="lib.Lattice.html#Bot">Bot</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#Bot_except">Bot_except</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.LTL.html#Breturn">Breturn</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bsetstack">Bsetstack</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.LTL.html#Bstore">Bstore</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<br/><br/><a name="constructor_C"></a><h2>C </h2>
-<a href="backend.Machabstr2mach.html#callstack_dom_cons">callstack_dom_cons</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_dom_nil">callstack_dom_nil</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_linked_cons">callstack_linked_cons</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_linked_nil">callstack_linked_nil</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_linked_one">callstack_linked_one</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.PPC.html#CARRY">CARRY</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Op.html#Ccomp">Ccomp</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ccompf">Ccompf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ccompimm">Ccompimm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ccompu">Ccompu</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ccompuimm">Ccompuimm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cminor.html#CEcond">CEcond</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#CEcondition">CEcondition</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#CEfalse">CEfalse</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.AST.html#Ceq">Ceq</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Cminor.html#CEtrue">CEtrue</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.AST.html#Cge">Cge</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Cgt">Cgt</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.PPC.html#Cint">Cint</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.AST.html#Cle">Cle</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Clt">Clt</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Op.html#Cmasknotzero">Cmasknotzero</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Cmaskzero">Cmaskzero</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.AST.html#Cne">Cne</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Op.html#Cnotcompf">Cnotcompf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.LTL.html#Cont">Cont</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Mem.html#Cont">Cont</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_cont">content_inject_cont</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_datum16">content_inject_datum16</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_datum32">content_inject_datum32</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_datum64">content_inject_datum64</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_datum8">content_inject_datum8</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject_undef">content_inject_undef</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPC.html#CRbit_0">CRbit_0</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CRbit_1">CRbit_1</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CRbit_2">CRbit_2</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CRbit_3">CRbit_3</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CR0_0">CR0_0</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CR0_1">CR0_1</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CR0_2">CR0_2</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CR0_3">CR0_3</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Constprop.html#csr_case1">csr_case1</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#csr_case2">csr_case2</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#csr_default">csr_default</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.PPC.html#Csymbol_high_signed">Csymbol_high_signed</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Csymbol_high_unsigned">Csymbol_high_unsigned</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Csymbol_low_signed">Csymbol_low_signed</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Csymbol_low_unsigned">Csymbol_low_unsigned</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#CTR">CTR</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<br/><br/><a name="constructor_D"></a><h2>D </h2>
-<a href="backend.Mem.html#Datum16">Datum16</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Datum32">Datum32</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Datum64">Datum64</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Datum8">Datum8</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cmconstr.html#divu_case1">divu_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#divu_default">divu_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp_refl">dstepp_refl</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp_trans">dstepp_trans</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_nop">dstep_nop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_pop">dstep_pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_pop_loop">dstep_pop_loop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_push">dstep_push</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstep_start">dstep_start</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<br/><br/><a name="constructor_E"></a><h2>E </h2>
-<a href="backend.Csharpminor.html#Eaddrof">Eaddrof</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Eassign">Eassign</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Eassign">Eassign</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ecall">Ecall</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Ecall">Ecall</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Econdition">Econdition</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Econdition">Econdition</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#Econs">Econs</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Econs">Econs</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Elet">Elet</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Elet">Elet</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#Eletvar">Eletvar</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Eletvar">Eletvar</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Eload">Eload</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Eload">Eload</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Enil">Enil</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Enil">Enil</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Eop">Eop</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Eop">Eop</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.RTLgen.html#Error">Error</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.PPC.html#Error">Error</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Cminor.html#Estore">Estore</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Estore">Estore</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#eval_Evar">eval_Evar</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#eval_Evar">eval_Evar</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case1">eval_static_condition_case1</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case2">eval_static_condition_case2</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case3">eval_static_condition_case3</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case4">eval_static_condition_case4</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case5">eval_static_condition_case5</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case6">eval_static_condition_case6</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case7">eval_static_condition_case7</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_case8">eval_static_condition_case8</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_default">eval_static_condition_default</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case1">eval_static_operation_case1</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case11">eval_static_operation_case11</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case12">eval_static_operation_case12</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case13">eval_static_operation_case13</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case14">eval_static_operation_case14</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case15">eval_static_operation_case15</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case16">eval_static_operation_case16</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case17">eval_static_operation_case17</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case18">eval_static_operation_case18</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case19">eval_static_operation_case19</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case2">eval_static_operation_case2</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case20">eval_static_operation_case20</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case21">eval_static_operation_case21</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case22">eval_static_operation_case22</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case23">eval_static_operation_case23</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case24">eval_static_operation_case24</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case25">eval_static_operation_case25</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case26">eval_static_operation_case26</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case27">eval_static_operation_case27</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case28">eval_static_operation_case28</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case29">eval_static_operation_case29</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case3">eval_static_operation_case3</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case30">eval_static_operation_case30</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case31">eval_static_operation_case31</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case32">eval_static_operation_case32</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case33">eval_static_operation_case33</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case34">eval_static_operation_case34</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case35">eval_static_operation_case35</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case36">eval_static_operation_case36</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case37">eval_static_operation_case37</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case38">eval_static_operation_case38</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case39">eval_static_operation_case39</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case4">eval_static_operation_case4</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case40">eval_static_operation_case40</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case41">eval_static_operation_case41</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case42">eval_static_operation_case42</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case43">eval_static_operation_case43</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case44">eval_static_operation_case44</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case45">eval_static_operation_case45</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case46">eval_static_operation_case46</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case47">eval_static_operation_case47</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case6">eval_static_operation_case6</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case7">eval_static_operation_case7</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case8">eval_static_operation_case8</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_case9">eval_static_operation_case9</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_default">eval_static_operation_default</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cminor.html#Evar">Evar</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Evar">Evar</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.LTL.html#exec_Bgetstack">exec_Bgetstack</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.RTL.html#exec_Iload">exec_Iload</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.RTL.html#exec_Inop">exec_Inop</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.RTL.html#exec_Iop">exec_Iop</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Linear.html#exec_Lgetstack">exec_Lgetstack</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Mach.html#exec_Mgetparam">exec_Mgetparam</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#exec_Mgetstack">exec_Mgetstack</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Machabstr.html#exec_Mgetstack">exec_Mgetstack</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Mach.html#exec_Mlabel">exec_Mlabel</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Machabstr.html#exec_Mlabel">exec_Mlabel</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Mach.html#exec_Msetstack">exec_Msetstack</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPC.html#exec_one">exec_one</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#exec_refl">exec_refl</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#exec_step_intro">exec_step_intro</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_refl">exec_straight_refl</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight_step">exec_straight_step</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.PPC.html#exec_trans">exec_trans</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<br/><br/><a name="constructor_F"></a><h2>F </h2>
-<a href="backend.Stacking.html#FI_arg">FI_arg</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#FI_local">FI_local</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#FI_saved_float">FI_saved_float</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#FI_saved_int">FI_saved_int</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.PPC.html#FPR0">FPR0</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR1">FPR1</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR10">FPR10</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR11">FPR11</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR12">FPR12</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR13">FPR13</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR14">FPR14</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR15">FPR15</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR16">FPR16</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR17">FPR17</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR18">FPR18</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR19">FPR19</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR2">FPR2</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR20">FPR20</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR21">FPR21</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR22">FPR22</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR23">FPR23</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR24">FPR24</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR25">FPR25</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR26">FPR26</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR27">FPR27</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR28">FPR28</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR29">FPR29</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR3">FPR3</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR30">FPR30</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR31">FPR31</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR4">FPR4</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR5">FPR5</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR6">FPR6</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR7">FPR7</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR8">FPR8</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FPR9">FPR9</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#FR">FR</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match_intro">frame_match_intro</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Locations.html#FT1">FT1</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#FT2">FT2</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#FT3">FT3</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F1">F1</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F10">F10</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F14">F14</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F15">F15</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F16">F16</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F17">F17</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F18">F18</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F19">F19</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F2">F2</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F20">F20</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F21">F21</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F22">F22</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F23">F23</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F24">F24</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F25">F25</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F26">F26</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F27">F27</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F28">F28</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F29">F29</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F3">F3</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F30">F30</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F31">F31</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F4">F4</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F5">F5</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F6">F6</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F7">F7</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F8">F8</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#F9">F9</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<br/><br/><a name="constructor_G"></a><h2>G </h2>
-<a href="backend.Machabstr.html#get_slot_intro">get_slot_intro</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.PPC.html#GPR0">GPR0</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR1">GPR1</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR10">GPR10</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR11">GPR11</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR12">GPR12</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR13">GPR13</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR14">GPR14</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR15">GPR15</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR16">GPR16</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR17">GPR17</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR18">GPR18</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR19">GPR19</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR2">GPR2</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR20">GPR20</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR21">GPR21</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR22">GPR22</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR23">GPR23</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR24">GPR24</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR25">GPR25</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR26">GPR26</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR27">GPR27</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR28">GPR28</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR29">GPR29</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR3">GPR3</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR30">GPR30</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR31">GPR31</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR4">GPR4</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR5">GPR5</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR6">GPR6</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR7">GPR7</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR8">GPR8</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#GPR9">GPR9</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<br/><br/><a name="constructor_I"></a><h2>I </h2>
-<a href="backend.Locations.html#Incoming">Incoming</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Lattice.html#Inj">Inj</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.RTL.html#Inop">Inop</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv_S">insert_lenv_S</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv_0">insert_lenv_0</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.PPC.html#IR">IR</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_cons">is_tail_cons</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail_refl">is_tail_refl</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Locations.html#IT1">IT1</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#IT2">IT2</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#IT3">IT3</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<br/><br/><a name="constructor_L"></a><h2>L </h2>
-<a href="backend.Linear.html#Lcall">Lcall</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lcond">Lcond</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="lib.Maps.html#Leaf">Leaf</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Inclusion.html#leaf">leaf</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Linear.html#Lgetstack">Lgetstack</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lgoto">Lgoto</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="lib.Coqlib.html#list_forall2_cons">list_forall2_cons</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_forall2_nil">list_forall2_nil</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_cons">list_norepet_cons</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet_nil">list_norepet_nil</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Linear.html#Llabel">Llabel</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lload">Lload</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.CSE.html#Load">Load</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Locations.html#Local">Local</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Linear.html#Lop">Lop</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.PPC.html#LR">LR</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Linear.html#Lreturn">Lreturn</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lsetstack">Lsetstack</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Linear.html#Lstore">Lstore</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Csharpminor.html#LVarray">LVarray</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#LVscalar">LVscalar</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<br/><br/><a name="constructor_M"></a><h2>M </h2>
-<a href="backend.Mach.html#Mcall">Mcall</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mcond">Mcond</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Cminorgenproof.html#mcs_cons">mcs_cons</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#mcs_nil">mcs_nil</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.AST.html#Mfloat32">Mfloat32</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mfloat64">Mfloat64</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Mach.html#Mgetparam">Mgetparam</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mgetstack">Mgetstack</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mgoto">Mgoto</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.AST.html#Mint16signed">Mint16signed</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mint16unsigned">Mint16unsigned</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mint32">Mint32</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mint8signed">Mint8signed</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Mint8unsigned">Mint8unsigned</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Mach.html#Mlabel">Mlabel</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mload">Mload</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mop">Mop</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mreturn">Mreturn</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Msetstack">Msetstack</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Mstore">Mstore</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_case1">mulimm_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_case2">mulimm_case2</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_default">mulimm_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_case1">mul_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_case2">mul_case2</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_default">mul_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<br/><br/><a name="constructor_N"></a><h2>N </h2>
-<a href="backend.Op.html#n">n</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Maps.html#Node">Node</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Inclusion.html#node">node</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Locations.html#norepet_cons">norepet_cons</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#norepet_nil">norepet_nil</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Cmconstr.html#notint_case1">notint_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_case2">notint_case2</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_case3">notint_case3</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_default">notint_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Machabstr2mach.html#notin_callstack_cons">notin_callstack_cons</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#notin_callstack_nil">notin_callstack_nil</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Constprop.html#Novalue">Novalue</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<br/><br/><a name="constructor_O"></a><h2>O </h2>
-<a href="backend.Op.html#Oabsf">Oabsf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oabsf">Oabsf</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Oadd">Oadd</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oadd">Oadd</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oaddf">Oaddf</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oaddf">Oaddf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oaddimm">Oaddimm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oaddrstack">Oaddrstack</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oaddrsymbol">Oaddrsymbol</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oand">Oand</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oand">Oand</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oandimm">Oandimm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ocast16signed">Ocast16signed</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ocast16signed">Ocast16signed</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ocast16unsigned">Ocast16unsigned</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ocast8signed">Ocast8signed</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ocast8signed">Ocast8signed</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ocast8unsigned">Ocast8unsigned</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ocmp">Ocmp</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ocmp">Ocmp</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ocmpf">Ocmpf</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ocmpu">Ocmpu</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Odiv">Odiv</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Odiv">Odiv</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Odivf">Odivf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Odivf">Odivf</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Odivu">Odivu</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Odivu">Odivu</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Ofloatconst">Ofloatconst</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ofloatconst">Ofloatconst</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ofloatofint">Ofloatofint</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ofloatofint">Ofloatofint</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Ofloatofintu">Ofloatofintu</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ofloatofintu">Ofloatofintu</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ointconst">Ointconst</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ointconst">Ointconst</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Ointoffloat">Ointoffloat</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Ointoffloat">Ointoffloat</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.RTLgen.html#OK">OK</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.PPC.html#OK">OK</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Csharpminor.html#Omod">Omod</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Omodu">Omodu</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Omove">Omove</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Omul">Omul</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Omul">Omul</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Omuladdf">Omuladdf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Omulf">Omulf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Omulf">Omulf</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Omulimm">Omulimm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Omulsubf">Omulsubf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Onand">Onand</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Onegf">Onegf</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Onegf">Onegf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Onor">Onor</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Onotint">Onotint</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Onxor">Onxor</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oor">Oor</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oor">Oor</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oorimm">Oorimm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.CSE.html#Op">Op</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case1">op_strength_reduction_case1</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case10">op_strength_reduction_case10</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case11">op_strength_reduction_case11</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case12">op_strength_reduction_case12</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case2">op_strength_reduction_case2</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case3">op_strength_reduction_case3</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case4">op_strength_reduction_case4</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case5">op_strength_reduction_case5</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case6">op_strength_reduction_case6</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case7">op_strength_reduction_case7</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case8">op_strength_reduction_case8</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_case9">op_strength_reduction_case9</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_default">op_strength_reduction_default</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Op.html#Orolm">Orolm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstr.html#or_case1">or_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#or_default">or_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Csharpminor.html#Oshl">Oshl</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oshl">Oshl</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oshr">Oshr</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oshr">Oshr</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oshrimm">Oshrimm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oshru">Oshru</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oshru">Oshru</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oshrximm">Oshrximm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Osingleoffloat">Osingleoffloat</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Osingleoffloat">Osingleoffloat</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#Osub">Osub</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Osub">Osub</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Osubf">Osubf</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Osubf">Osubf</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Osubimm">Osubimm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#Oundef">Oundef</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Locations.html#Outgoing">Outgoing</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Csharpminor.html#Out_exit">Out_exit</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Out_exit">Out_exit</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#Out_normal">Out_normal</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Out_normal">Out_normal</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Out_return">Out_return</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Out_return">Out_return</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oxor">Oxor</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#Oxor">Oxor</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#Oxorimm">Oxorimm</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<br/><br/><a name="constructor_P"></a><h2>P </h2>
-<a href="backend.PPC.html#Padd">Padd</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Paddi">Paddi</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Paddis">Paddis</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Paddze">Paddze</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pallocframe">Pallocframe</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pandc">Pandc</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pandis_">Pandis_</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pandi_">Pandi_</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pand_">Pand_</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pb">Pb</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbctr">Pbctr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbctrl">Pbctrl</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbf">Pbf</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbl">Pbl</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pblr">Pblr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pbt">Pbt</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#PC">PC</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcmplw">Pcmplw</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcmplwi">Pcmplwi</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcmpw">Pcmpw</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcmpwi">Pcmpwi</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pcror">Pcror</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pdivw">Pdivw</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pdivwu">Pdivwu</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Peqv">Peqv</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pextsb">Pextsb</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pextsh">Pextsh</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfabs">Pfabs</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfadd">Pfadd</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfcmpu">Pfcmpu</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfcti">Pfcti</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfdiv">Pfdiv</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfmadd">Pfmadd</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfmr">Pfmr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfmsub">Pfmsub</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfmul">Pfmul</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfneg">Pfneg</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfreeframe">Pfreeframe</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfrsp">Pfrsp</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfsub">Pfsub</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pfundef">Pfundef</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pictf">Pictf</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Piuctf">Piuctf</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Piundef">Piundef</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plabel">Plabel</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plbz">Plbz</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plbzx">Plbzx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plfd">Plfd</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plfdx">Plfdx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plfi">Plfi</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plfs">Plfs</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plfsx">Plfsx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plha">Plha</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plhax">Plhax</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plhz">Plhz</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plhzx">Plhzx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plwz">Plwz</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Plwzx">Plwzx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmfcrbit">Pmfcrbit</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmflr">Pmflr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmr">Pmr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmtctr">Pmtctr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmtlr">Pmtlr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmulli">Pmulli</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pmullw">Pmullw</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pnand">Pnand</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pnor">Pnor</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Por">Por</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Porc">Porc</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pori">Pori</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Poris">Poris</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Prlwinm">Prlwinm</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pslw">Pslw</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psraw">Psraw</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psrawi">Psrawi</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psrw">Psrw</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstb">Pstb</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstbx">Pstbx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstfd">Pstfd</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstfdx">Pstfdx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstfs">Pstfs</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstfsx">Pstfsx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psth">Psth</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psthx">Psthx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstw">Pstw</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pstwx">Pstwx</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psubfc">Psubfc</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Psubfic">Psubfic</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pxor">Pxor</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pxori">Pxori</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pxoris">Pxoris</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<br/><br/><a name="constructor_R"></a><h2>R </h2>
-<a href="backend.Locations.html#R">R</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.LTL.html#Return">Return</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.RTLgenproof1.html#return_reg_ok_none">return_reg_ok_none</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#return_reg_ok_some">return_reg_ok_some</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="lib.Integers.html#RLW_Sbad">RLW_Sbad</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S0">RLW_S0</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S1">RLW_S1</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S2">RLW_S2</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S3">RLW_S3</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S4">RLW_S4</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S5">RLW_S5</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#RLW_S6">RLW_S6</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_case1">rolm_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_case2">rolm_case2</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_default">rolm_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Locations.html#R10">R10</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R13">R13</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R14">R14</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R15">R15</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R16">R16</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R17">R17</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R18">R18</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R19">R19</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Op.html#r2">r2</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#r2">r2</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Locations.html#R20">R20</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R21">R21</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R22">R22</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R23">R23</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R24">R24</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R25">R25</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R26">R26</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R27">R27</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R28">R28</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R29">R29</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R3">R3</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R30">R30</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R31">R31</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R4">R4</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R5">R5</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R6">R6</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R7">R7</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R8">R8</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#R9">R9</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<br/><br/><a name="constructor_S"></a><h2>S </h2>
-<a href="backend.Locations.html#S">S</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Cminor.html#Sblock">Sblock</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Sblock">Sblock</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Scons">Scons</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Scons">Scons</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Machabstr.html#set_slot_intro">set_slot_intro</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Cminor.html#Sexit">Sexit</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Sexit">Sexit</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Sexpr">Sexpr</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Sexpr">Sexpr</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cmconstr.html#shift_case1">shift_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#shift_default">shift_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Csharpminor.html#Sifthenelse">Sifthenelse</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Sifthenelse">Sifthenelse</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Mem.html#Size16">Size16</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Size32">Size32</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Size64">Size64</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#Size8">Size8</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Csharpminor.html#Sloop">Sloop</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Sloop">Sloop</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Snil">Snil</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Snil">Snil</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#Sreturn">Sreturn</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#Sreturn">Sreturn</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr_intro">state_incr_intro</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_refl">stepp_refl</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepp_trans">stepp_trans</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_loop">step_loop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_nop">step_nop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_pop">step_pop</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_push">step_push</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_start">step_start</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cmconstr.html#subf_case1">subf_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#subf_default">subf_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_case1">sub_case1</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_case2">sub_case2</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_case3">sub_case3</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_case4">sub_case4</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_default">sub_default</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<br/><br/><a name="constructor_T"></a><h2>T </h2>
-<a href="backend.RTLgenproof1.html#target_regs_cons">target_regs_cons</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_regs_nil">target_regs_nil</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_immut_var">target_reg_immut_var</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.AST.html#Tfloat">Tfloat</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#Tint">Tint</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.RTLtyping.html#tReg">tReg</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#tTy">tTy</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<br/><br/><a name="constructor_U"></a><h2>U </h2>
-<a href="backend.Mem.html#Undef">Undef</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<br/><br/><a name="constructor_V"></a><h2>V </h2>
-<a href="backend.Mem.html#val_cons_inject">val_cons_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_content_inject_base">val_content_inject_base</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_content_inject_8">val_content_inject_8</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject_float">val_inject_float</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject_int">val_inject_int</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject_ptr">val_inject_ptr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_nil_inject">val_nil_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_cons">vars_vals_cons</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_nil">vars_vals_nil</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgen.html#Var_global">Var_global</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#Var_local">Var_local</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#Var_stack_array">Var_stack_array</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#Var_stack_scalar">Var_stack_scalar</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Values.html#Vfloat">Vfloat</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vint">Vint</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Constpropproof.html#vlma_cons">vlma_cons</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Constpropproof.html#vlma_nil">vlma_nil</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Values.html#Vptr">Vptr</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vundef">Vundef</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<br/><br/><a name="constructor_W"></a><h2>W </h2>
-<a href="backend.LTLtyping.html#wt_Bgetstack">wt_Bgetstack</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_Bop">wt_Bop</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_Bopmove">wt_Bopmove</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_Bopundef">wt_Bopundef</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_Bsetstack">wt_Bsetstack</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_Inop">wt_Inop</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_Iop">wt_Iop</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_Iopmove">wt_Iopmove</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_Iopundef">wt_Iopundef</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lgetstack">wt_Lgetstack</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lop">wt_Lop</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lopmove">wt_Lopmove</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lopundef">wt_Lopundef</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_Lsetstack">wt_Lsetstack</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_Mgetstack">wt_Mgetstack</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_Mlabel">wt_Mlabel</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_Msetstack">wt_Msetstack</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<br/><br/><a name="constructor__"></a><h2>_ </h2>
-<a href="backend.Lineartyping.html#_">_</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.LTLtyping.html#_">_</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<br/><br/><hr/>
-<h1>Inductive Index</h1>
-<a name="inductive_A"></a><h2>A </h2>
-<a href="backend.Op.html#a">a</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#a">a</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstr.html#addf_cases">addf_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_cases">addimm_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Op.html#addressing">addressing</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_cases">addressing_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_cases">addr_strength_reduction_cases</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cmconstr.html#add_cases">add_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Stackingproof.html#agree">agree</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Csharpminor.html#alloc_variables">alloc_variables</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Constprop.html#approx">approx</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<br/><br/><a name="inductive_B"></a><h2>B </h2>
-<a href="lib.Inclusion.html#bin">bin</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Csharpminor.html#bind_parameters">bind_parameters</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.LTL.html#block">block</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Mem.html#block_contents">block_contents</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_inject">block_contents_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Values.html#bool_of_val">bool_of_val</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Lineartyping.html#bounds">bounds</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<br/><br/><a name="inductive_C"></a><h2>C </h2>
-<a href="backend.Machabstr2mach.html#callstack_dom">callstack_dom</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_invariant">callstack_invariant</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machabstr2mach.html#callstack_linked">callstack_linked</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.AST.html#comparison">comparison</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Cminor.html#condexpr">condexpr</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Op.html#condition">condition</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Constprop.html#cond_strength_reduction_cases">cond_strength_reduction_cases</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.PPC.html#constant">constant</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mem.html#content">content</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#content_inject">content_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Linearizeproof.html#cont_for_outcome">cont_for_outcome</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.PPC.html#crbit">crbit</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<br/><br/><a name="inductive_D"></a><h2>D </h2>
-<a href="backend.Cmconstr.html#divu_cases">divu_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Parallelmove.html#dstep">dstep</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#dstepp">dstepp</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<br/><br/><a name="inductive_E"></a><h2>E </h2>
-<a href="backend.Csharpminor.html#eval_expr">eval_expr</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#eval_expr">eval_expr</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_cases">eval_static_condition_cases</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_cases">eval_static_operation_cases</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Machabstr.html#exec_instr">exec_instr</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.RTL.html#exec_instr">exec_instr</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.LTL.html#exec_instr">exec_instr</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Linear.html#exec_instr">exec_instr</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Mach.html#exec_instr">exec_instr</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPC.html#exec_step">exec_step</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#exec_steps">exec_steps</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPCgenproof1.html#exec_straight">exec_straight</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.Csharpminor.html#expr">expr</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#expr">expr</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#exprlist">exprlist</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#exprlist">exprlist</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<br/><br/><a name="inductive_F"></a><h2>F </h2>
-<a href="backend.Cminorgenproof.html#frame">frame</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Stacking.html#frame_env">frame_env</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#frame_index">frame_index</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Machabstr2mach.html#frame_match">frame_match</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.PPC.html#freg">freg</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#function">function</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Csharpminor.html#function">function</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.RTL.html#function">function</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.LTL.html#function">function</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Cminor.html#function">function</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Linear.html#function">function</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<br/><br/><a name="inductive_G"></a><h2>G </h2>
-<a href="backend.Globalenvs.html#genv">genv</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Machabstr.html#get_slot">get_slot</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.InterfGraph.html#graph">graph</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<br/><br/><a name="inductive_I"></a><h2>I </h2>
-<a href="backend.PPC.html#immediate">immediate</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#immediate">immediate</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.LTLtyping.html#Incoming">Incoming</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.Lineartyping.html#Incoming">Incoming</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Cmconstrproof.html#insert_lenv">insert_lenv</a> [in <a href="backend.Cmconstrproof.html">backend.Cmconstrproof</a>]<br/>
-<a href="backend.Linear.html#instruction">instruction</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.PPC.html#instruction">instruction</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.RTL.html#instruction">instruction</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Mach.html#instruction">instruction</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="lib.Integers.html#int">int</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.PPC.html#ireg">ireg</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Linearizeproof.html#is_tail">is_tail</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<br/><br/><a name="inductive_L"></a><h2>L </h2>
-<a href="lib.Coqlib.html#list_forall2">list_forall2</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#list_norepet">list_norepet</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Locations.html#loc">loc</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Csharpminor.html#local_variable">local_variable</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<br/><br/><a name="inductive_M"></a><h2>M </h2>
-<a href="backend.RTLgen.html#mapping">mapping</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#map_wf">map_wf</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_callstack">match_callstack</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_env">match_env</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#match_env">match_env</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_globalenvs">match_globalenvs</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#match_var">match_var</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#mem">mem</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.AST.html#memory_chunk">memory_chunk</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Mem.html#memory_size">memory_size</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#mem_inject">mem_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Locations.html#mreg">mreg</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_cases">mulimm_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_cases">mul_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.RTLtyping.html#myT">myT</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<br/><br/><a name="inductive_N"></a><h2>N </h2>
-<a href="backend.Locations.html#norepet">norepet</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Cmconstr.html#notint_cases">notint_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Machabstr2mach.html#notin_callstack">notin_callstack</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.CSE.html#numbering">numbering</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<br/><br/><a name="inductive_O"></a><h2>O </h2>
-<a href="backend.Csharpminor.html#operation">operation</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#operation">operation</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_cases">op_strength_reduction_cases</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cmconstr.html#or_cases">or_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cminor.html#outcome">outcome</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.LTL.html#outcome">outcome</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.PPC.html#outcome">outcome</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Csharpminor.html#outcome">outcome</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminorgenproof.html#outcome_inject">outcome_inject</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<br/><br/><a name="inductive_P"></a><h2>P </h2>
-<a href="backend.PPC.html#preg">preg</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.AST.html#program">program</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<br/><br/><a name="inductive_R"></a><h2>R </h2>
-<a href="backend.RTLgen.html#res">res</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#return_reg_ok">return_reg_ok</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.CSE.html#rhs">rhs</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Integers.html#rlw_state">rlw_state</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_cases">rolm_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<br/><br/><a name="inductive_S"></a><h2>S </h2>
-<a href="backend.Machabstr.html#set_slot">set_slot</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Cmconstr.html#shift_cases">shift_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.AST.html#signature">signature</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Locations.html#slot">slot</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Kildall.html#state">state</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.RTLgen.html#state">state</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Kildall.html#state">state</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_incr">state_incr</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Parallelmove.html#step">step</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepp">stepp</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Csharpminor.html#stmt">stmt</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#stmt">stmt</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#stmtlist">stmtlist</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#stmtlist">stmtlist</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cmconstr.html#subf_cases">subf_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_cases">sub_cases</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<br/><br/><a name="inductive_T"></a><h2>T </h2>
-<a href="backend.RTLgenproof1.html#target_regs_ok">target_regs_ok</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#target_reg_ok">target_reg_ok</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.PPCgenproof.html#transl_code_at_pc">transl_code_at_pc</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="lib.Maps.html#tree">tree</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.AST.html#typ">typ</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="lib.Lattice.html#t_">t_</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#t_">t_</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<br/><br/><a name="inductive_U"></a><h2>U </h2>
-<a href="lib.union_find.html#unionfind">unionfind</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<br/><br/><a name="inductive_V"></a><h2>V </h2>
-<a href="backend.Values.html#val">val</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Mem.html#val_content_inject">val_content_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_inject">val_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#val_list_inject">val_list_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Constpropproof.html#val_list_match_approx">val_list_match_approx</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#vars_vals_match">vars_vals_match</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgen.html#var_info">var_info</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<br/><br/><a name="inductive_W"></a><h2>W </h2>
-<a href="backend.LTLtyping.html#wt_block">wt_block</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_function">wt_function</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_function">wt_function</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_instr">wt_instr</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_instr">wt_instr</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_instr">wt_instr</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<br/><br/><hr/>
-<h1>Definition Index</h1>
-<a name="definition_A"></a><h2>A </h2>
-<a href="backend.Values.html#absf">absf</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#absfloat">absfloat</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#add">add</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Sets.html#add">add</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Cmconstr.html#add">add</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.RTLtyping.html#add">add</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Integers.html#add">add</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#addf">addf</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#addf">addf</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#addf_match">addf_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addf_match_aux">addf_match_aux</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.PPCgen.html#addimm">addimm</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Cmconstr.html#addimm">addimm</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addimm_match">addimm_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.PPCgen.html#addimm_1">addimm_1</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#addimm_2">addimm_2</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Cmconstr.html#addressing">addressing</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#addressing_match">addressing_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction">addr_strength_reduction</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#addr_strength_reduction_match">addr_strength_reduction_match</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cminorgen.html#addr_taken_expr">addr_taken_expr</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#addr_taken_stmt">addr_taken_stmt</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Allocation.html#add_call">add_call</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#add_cond">add_cond</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Coloring.html#add_edges_instr">add_edges_instr</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#add_edges_instrs">add_edges_instrs</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Allocation.html#add_entry">add_entry</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Globalenvs.html#add_funct">add_funct</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#add_functs">add_functs</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#add_globals">add_globals</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.RTLgen.html#add_instr">add_instr</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf">add_interf</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#add_interf_call">add_interf_call</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#add_interf_entry">add_interf_entry</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#add_interf_live">add_interf_live</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#add_interf_move">add_interf_move</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.InterfGraph.html#add_interf_mreg">add_interf_mreg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#add_interf_op">add_interf_op</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#add_interf_params">add_interf_params</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.RTLgen.html#add_letvar">add_letvar</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.CSE.html#add_load">add_load</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Allocation.html#add_load">add_load</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Cmconstr.html#add_match">add_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#add_match_aux">add_match_aux</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.RTLgen.html#add_move">add_move</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Allocation.html#add_move">add_move</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#add_op">add_op</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.CSE.html#add_op">add_op</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.InterfGraph.html#add_pref">add_pref</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#add_prefs_call">add_prefs_call</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.InterfGraph.html#add_pref_mreg">add_pref_mreg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Allocation.html#add_reload">add_reload</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#add_reloads">add_reloads</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#add_return">add_return</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.CSE.html#add_rhs">add_rhs</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Allocation.html#add_spill">add_spill</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#add_store">add_store</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Kildall.html#add_successors">add_successors</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Globalenvs.html#add_symbol">add_symbol</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Kildall.html#add_to_worklist">add_to_worklist</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Allocation.html#add_undefs">add_undefs</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.RTLgen.html#add_var">add_var</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#add_vars">add_vars</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Allocproof.html#agree">agree</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.PPCgenproof1.html#agree">agree</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="lib.Coqlib.html#align">align</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Mach.html#align_16_top">align_16_top</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mem.html#alloc">alloc</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Coloring.html#alloc_of_coloring">alloc_of_coloring</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.RTLgen.html#alloc_reg">alloc_reg</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#alloc_regs">alloc_regs</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.InterfGraph.html#all_interf_regs">all_interf_regs</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Allocation.html#analyze">analyze</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Constprop.html#analyze">analyze</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.CSE.html#analyze">analyze</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Integers.html#and">and</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#and">and</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#and">and</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#andimm">andimm</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.PPCgen.html#andimm">andimm</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="lib.Maps.html#append">append</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Main.html#apply_partial">apply_partial</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#apply_total">apply_total</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Constprop.html#approx_regs">approx_regs</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cminorgen.html#assign_variable">assign_variable</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#assign_variables">assign_variables</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<br/><br/><a name="definition_B"></a><h2>B </h2>
-<a href="backend.Parallelmove.html#base_case_Pmov_dec">base_case_Pmov_dec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Kildall.html#basic_block_list">basic_block_list</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#basic_block_map">basic_block_map</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#bbmap">bbmap</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.RTLgen.html#bind">bind</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Cminorgen.html#bind">bind</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.RTLgen.html#bind2">bind2</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="lib.Inclusion.html#bin_A">bin_A</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Integers.html#bits_of_Z">bits_of_Z</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#bitwise_binop">bitwise_binop</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#block">block</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Mem.html#block_agree">block_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_agree">block_contents_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#block_contents_extends">block_contents_extends</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Lattice.html#bot">bot</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#bot">bot</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#bot">bot</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Sets.html#bot">bot</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#bot">bot</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Tunneling.html#branch_target">branch_target</a> [in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Tunneling.html#branch_target_rec">branch_target_rec</a> [in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Cminorgen.html#build_compilenv">build_compilenv</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<br/><br/><a name="definition_C"></a><h2>C </h2>
-<a href="backend.Machabstr2mach.html#callstack">callstack</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Cminorgenproof.html#callstack">callstack</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.LTL.html#call_regs">call_regs</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Csharpminor.html#cast">cast</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="lib.Integers.html#cast16signed">cast16signed</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cast16signed">cast16signed</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#cast16signed">cast16signed</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#cast16unsigned">cast16unsigned</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#cast16unsigned">cast16unsigned</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cast16unsigned">cast16unsigned</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#cast8signed">cast8signed</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#cast8signed">cast8signed</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cast8signed">cast8signed</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#cast8unsigned">cast8unsigned</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#cast8unsigned">cast8unsigned</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cast8unsigned">cast8unsigned</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Inclusion.html#check_all_leaves">check_all_leaves</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Coloring.html#check_coloring">check_coloring</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#check_coloring_1">check_coloring_1</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#check_coloring_2">check_coloring_2</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Coloring.html#check_coloring_3">check_coloring_3</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Mem.html#check_cont">check_cont</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Integers.html#check_equal_on_range">check_equal_on_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Mach.html#chunk_of_type">chunk_of_type</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Linearize.html#cleanup_code">cleanup_code</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearize.html#cleanup_function">cleanup_function</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Cmconstr.html#cmp">cmp</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#cmp">cmp</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#cmp">cmp</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#cmpf">cmpf</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#cmpf">cmpf</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#cmpu">cmpu</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#cmpu">cmpu</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#cmpu">cmpu</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#cmp_mismatch">cmp_mismatch</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.LTL.html#code">code</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.PPC.html#code">code</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.RTL.html#code">code</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Linear.html#code">code</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Mach.html#code">code</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPCgen.html#code_size">code_size</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgenproof.html#code_tail">code_tail</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="lib.Maps.html#combine">combine</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.PPC.html#compare_float">compare_float</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#compare_sint">compare_sint</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#compare_uint">compare_uint</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Cminorgen.html#compilenv">compilenv</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cmconstr.html#condexpr_of_expr">condexpr_of_expr</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#conditionalexpr">conditionalexpr</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Constprop.html#cond_strength_reduction">cond_strength_reduction</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#cond_strength_reduction_match">cond_strength_reduction_match</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.RTLtyping.html#consistent">consistent</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.PPC.html#const_high">const_high</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#const_low">const_low</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mem.html#contentmap">contentmap</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#contentmap_agree">contentmap_agree</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#contentmap_inject">contentmap_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Coloringproof.html#correct_alloc_instr">correct_alloc_instr</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.Coloringproof.html#correct_interf_instr">correct_interf_instr</a> [in <a href="backend.Coloringproof.html">backend.Coloringproof</a>]<br/>
-<a href="backend.PPCgen.html#crbit_for_cond">crbit_for_cond</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#crbit_for_fcmp">crbit_for_fcmp</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#crbit_for_icmp">crbit_for_icmp</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<br/><br/><a name="definition_D"></a><h2>D </h2>
-<a href="backend.RTLtyping.html#decode">decode</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#def">def</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLtyping.html#definite">definite</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Conventions.html#destroyed_at_call">destroyed_at_call</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#destroyed_at_call_regs">destroyed_at_call_regs</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Locations.html#diff">diff</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#diff_dec">diff_dec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#disjoint">disjoint</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Values.html#divf">divf</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#divf">divf</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#divs">divs</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#divs">divs</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#divs">divs</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#divu">divu</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#divu">divu</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#divu">divu</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#divu_match">divu_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Allocproof_aux.html#Done_well_formed">Done_well_formed</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Conventions.html#drop1">drop1</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#drop2">drop2</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<br/><br/><a name="definition_E"></a><h2>E </h2>
-<a href="lib.Sets.html#elements">elements</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#elements">elements</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt">elt</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTLtyping.html#elt">elt</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Sets.html#elt">elt</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.union_find.html#elt">elt</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#elt">elt</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#elt">elt</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.Maps.html#elt">elt</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt">elt</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt">elt</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt_eq">elt_eq</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt_eq">elt_eq</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt_eq">elt_eq</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#elt_eq">elt_eq</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Sets.html#empty">empty</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#empty">empty</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.union_find.html#empty">empty</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.RTLtyping.html#empty">empty</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Globalenvs.html#empty">empty</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Mem.html#empty">empty</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#empty_block">empty_block</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Csharpminor.html#empty_env">empty_env</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Machabstr.html#empty_frame">empty_frame</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.InterfGraph.html#empty_graph">empty_graph</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.CSE.html#empty_numbering">empty_numbering</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.RTLtyping.html#encode">encode</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Linearize.html#enumerate">enumerate</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Csharpminor.html#env">env</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Parallelmove.html#Env">Env</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cminor.html#env">env</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Mach.html#eq">eq</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="lib.Ordered.html#eq">eq</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.RTLtyping.html#eq">eq</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.CSEproof.html#eq">eq</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.Maps.html#eq">eq</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#eq">eq</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Ordered.html#eq">eq</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.Registers.html#eq">eq</a> [in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="lib.Ordered.html#eq">eq</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.PPC.html#eq">eq</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Integers.html#eq">eq</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqm">eqm</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#eqmod">eqmod</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.CSE.html#equation_holds">equation_holds</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Values.html#eq_block">eq_block</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.CSE.html#eq_list_valnum">eq_list_valnum</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#eq_rhs">eq_rhs</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#eq_valnum">eq_valnum</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.RTLtyping.html#error">error</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLgen.html#error">error</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Op.html#eval_addressing">eval_addressing</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_addressing_total">eval_addressing_total</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_compare_null">eval_compare_null</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#eval_compare_null">eval_compare_null</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#eval_condition">eval_condition</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#eval_condition_total">eval_condition_total</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Cminorgenproof.html#eval_exprlist_prop">eval_exprlist_prop</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#eval_expr_prop">eval_expr_prop</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#eval_funcall_prop">eval_funcall_prop</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Op.html#eval_operation">eval_operation</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Csharpminor.html#eval_operation">eval_operation</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Op.html#eval_operation_total">eval_operation_total</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition">eval_static_condition</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_condition_match">eval_static_condition_match</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation">eval_static_operation</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#eval_static_operation_match">eval_static_operation_match</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Parallelmove.html#exec">exec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_blocks_prop">exec_blocks_prop</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_blocks_prop">exec_blocks_prop</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_block_prop">exec_block_prop</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_block_prop">exec_block_prop</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_function_body_prop">exec_function_body_prop</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_function_body_prop">exec_function_body_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Machtyping.html#exec_function_body_prop">exec_function_body_prop</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Stackingproof.html#exec_function_prop">exec_function_prop</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Machtyping.html#exec_function_prop">exec_function_prop</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_function_prop">exec_function_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Constpropproof.html#exec_function_prop">exec_function_prop</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_function_prop">exec_function_prop</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_function_prop">exec_function_prop</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.CSEproof.html#exec_function_prop">exec_function_prop</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_function_prop">exec_function_prop</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Allocproof.html#exec_function_prop">exec_function_prop</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.RTLtyping.html#exec_function_subject_reduction">exec_function_subject_reduction</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.PPC.html#exec_instr">exec_instr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Allocproof.html#exec_instrs_prop">exec_instrs_prop</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_instrs_prop">exec_instrs_prop</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_instrs_prop">exec_instrs_prop</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.CSEproof.html#exec_instrs_prop">exec_instrs_prop</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Constpropproof.html#exec_instrs_prop">exec_instrs_prop</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_instrs_prop">exec_instrs_prop</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Allocproof.html#exec_instr_prop">exec_instr_prop</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Machabstr2mach.html#exec_instr_prop">exec_instr_prop</a> [in <a href="backend.Machabstr2mach.html">backend.Machabstr2mach</a>]<br/>
-<a href="backend.Machtyping.html#exec_instr_prop">exec_instr_prop</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Constpropproof.html#exec_instr_prop">exec_instr_prop</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.CSEproof.html#exec_instr_prop">exec_instr_prop</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Tunnelingproof.html#exec_instr_prop">exec_instr_prop</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Stackingproof.html#exec_instr_prop">exec_instr_prop</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Linearizeproof.html#exec_instr_prop">exec_instr_prop</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.PPCgenproof.html#exec_instr_prop">exec_instr_prop</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.RTLtyping.html#exec_instr_subject_reduction">exec_instr_subject_reduction</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Csharpminor.html#exec_program">exec_program</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.LTL.html#exec_program">exec_program</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Cminor.html#exec_program">exec_program</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.RTL.html#exec_program">exec_program</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Mach.html#exec_program">exec_program</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Machabstr.html#exec_program">exec_program</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Linear.html#exec_program">exec_program</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.PPC.html#exec_program">exec_program</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Cminorgenproof.html#exec_stmtlist_prop">exec_stmtlist_prop</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#exec_stmt_prop">exec_stmt_prop</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Mem.html#extends">extends</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#extend_inject">extend_inject</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<br/><br/><a name="definition_F"></a><h2>F </h2>
-<a href="backend.Globalenvs.html#find_funct">find_funct</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.LTL.html#find_function">find_function</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Mach.html#find_function">find_function</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.RTL.html#find_function">find_function</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Linear.html#find_function">find_function</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Allocproof.html#find_function2">find_function2</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Globalenvs.html#find_funct_ptr">find_funct_ptr</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.PPC.html#find_instr">find_instr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#find_label">find_label</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPCgenproof.html#find_label">find_label</a> [in <a href="backend.PPCgenproof.html">backend.PPCgenproof</a>]<br/>
-<a href="backend.Linear.html#find_label">find_label</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.RTLgen.html#find_letvar">find_letvar</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.CSE.html#find_load">find_load</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#find_op">find_op</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#find_rhs">find_rhs</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Globalenvs.html#find_symbol">find_symbol</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Op.html#find_symbol_offset">find_symbol_offset</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.CSE.html#find_valnum_rhs">find_valnum_rhs</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.RTLgen.html#find_var">find_var</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Kildall.html#fixpoint">fixpoint</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint">fixpoint</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#fixpoint">fixpoint</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="lib.Inclusion.html#flatten">flatten</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#flatten_aux">flatten_aux</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.PPCgen.html#floatcomp">floatcomp</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Values.html#floatofint">floatofint</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#floatofint">floatofint</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#floatofintu">floatofintu</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#floatofintu">floatofintu</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Lineartyping.html#float_callee_save">float_callee_save</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Conventions.html#float_callee_save_regs">float_callee_save_regs</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Lineartyping.html#float_local">float_local</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Conventions.html#float_param_regs">float_param_regs</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Csharpminor.html#fn_params_names">fn_params_names</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#fn_variables">fn_variables</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Csharpminor.html#fn_vars_names">fn_vars_names</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="lib.Sets.html#fold">fold</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#fold">fold</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTLtyping.html#fold2">fold2</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Sets.html#for_all">for_all</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Machabstr.html#frame">frame</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Mem.html#free">free</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#free_list">free_list</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgen.html#freg_of">freg_of</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Lineartyping.html#function_bounds">function_bounds</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<br/><br/><a name="definition_G"></a><h2>G </h2>
-<a href="lib.Lattice.html#ge">ge</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.CSE.html#ge">ge</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Lattice.html#ge">ge</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#ge">ge</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#ge">ge</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#ge">ge</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Cminor.html#genv">genv</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.LTL.html#genv">genv</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.PPC.html#genv">genv</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Csharpminor.html#genv">genv</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.RTL.html#genv">genv</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Mach.html#genv">genv</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Linear.html#genv">genv</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="lib.Maps.html#get">get</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#get">get</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#get">get</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Parallelmove.html#Get">Get</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#get">get</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Lattice.html#get">get</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#get">get</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Parallelmove.html#get">get</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLtyping.html#get">get</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#getdst">getdst</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Mem.html#getN">getN</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Parallelmove.html#getsrc">getsrc</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Globalenvs.html#globalenv">globalenv</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#globalenv_initmem">globalenv_initmem</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Kildall.html#good_state">good_state</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.PPC.html#goto_label">goto_label</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#gpr_or_zero">gpr_or_zero</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.InterfGraph.html#graph_incl">graph_incl</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<br/><br/><a name="definition_H"></a><h2>H </h2>
-<a href="lib.Integers.html#half_modulus">half_modulus</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#has_type">has_type</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#has_type_list">has_type_list</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Parallelmove.html#head_but_last">head_but_last</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Mem.html#high_bound">high_bound</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgen.html#high_s">high_s</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#high_u">high_u</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<br/><br/><a name="definition_I"></a><h2>I </h2>
-<a href="backend.AST.html#ident">ident</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="lib.union_find.html#identify">identify</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#identify_base">identify_base</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.AST.html#ident_eq">ident_eq</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Cmconstr.html#ifthenelse">ifthenelse</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.RTLtyping.html#included">included</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Locations.html#index">index</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#index">index</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#index">index</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Stackingproof.html#index_diff">index_diff</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Conventions.html#index_float_callee_save">index_float_callee_save</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#index_int_callee_save">index_int_callee_save</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Stackingproof.html#index_val">index_val</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Stackingproof.html#index_valid">index_valid</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="lib.Maps.html#init">init</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#init">init</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#init">init</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#init">init</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Machabstr.html#init_frame">init_frame</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.RTLgen.html#init_mapping">init_mapping</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Globalenvs.html#init_mem">init_mem</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.RTL.html#init_regs">init_regs</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.RTLgen.html#init_state">init_state</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Mem.html#inject_incr">inject_incr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Inclusion.html#insert_bin">insert_bin</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.InterfGraph.html#interfere">interfere</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#interfere_mreg">interfere_mreg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Coloring.html#interf_graph">interf_graph</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Cmconstr.html#intoffloat">intoffloat</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#intoffloat">intoffloat</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Constprop.html#intval">intval</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Lineartyping.html#int_callee_save">int_callee_save</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Conventions.html#int_callee_save_regs">int_callee_save_regs</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Lineartyping.html#int_local">int_local</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="lib.Integers.html#int_of_one_bits">int_of_one_bits</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Conventions.html#int_param_regs">int_param_regs</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Mem.html#in_bounds">in_bounds</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Kildall.html#in_incr">in_incr</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="lib.Integers.html#in_range">in_range</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.PPCgen.html#ireg_of">ireg_of</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Kildall.html#is_basic_block_head">is_basic_block_head</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Values.html#is_bool">is_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.PPCgenproof1.html#is_data_reg">is_data_reg</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="lib.Integers.html#is_false">is_false</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#is_false">is_false</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Tunneling.html#is_goto_block">is_goto_block</a> [in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.PPC.html#is_label">is_label</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#is_label">is_label</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Linear.html#is_label">is_label</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Op.html#is_move_operation">is_move_operation</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="lib.Integers.html#is_power2">is_power2</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#is_rlw_mask">is_rlw_mask</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#is_rlw_mask_rec">is_rlw_mask_rec</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.CSE.html#is_trivial_op">is_trivial_op</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Integers.html#is_true">is_true</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#is_true">is_true</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Kildall.html#iterate">iterate</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#iter_step">iter_step</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<br/><br/><a name="definition_K"></a><h2>K </h2>
-<a href="backend.CSE.html#kill_loads">kill_loads</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#kill_load_eqs">kill_load_eqs</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<br/><br/><a name="definition_L"></a><h2>L </h2>
-<a href="backend.Linear.html#label">label</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.PPC.html#label">label</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#label">label</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.PPC.html#label_pos">label_pos</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Parallelmove.html#last">last</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Linearize.html#lbl">lbl</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearize.html#lbl">lbl</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="lib.Inclusion.html#leaf">leaf</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#leaf">leaf</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="lib.Inclusion.html#leaf">leaf</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Cminor.html#letenv">letenv</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#letenv">letenv</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cmconstr.html#lift">lift</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#lift_condexpr">lift_condexpr</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#lift_expr">lift_expr</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#lift_exprlist">lift_exprlist</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Linearize.html#linearize_block">linearize_block</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearize.html#linearize_body">linearize_body</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearize.html#linearize_function">linearize_function</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Machtyping.html#link_invariant">link_invariant</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Parallelmove.html#listsLoc2Moves">listsLoc2Moves</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocation.html#listsLoc2Moves">listsLoc2Moves</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="lib.Coqlib.html#list_disjoint">list_disjoint</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Allocproof.html#live0">live0</a> [in <a href="backend.Allocproof.html">backend.Allocproof</a>]<br/>
-<a href="backend.Mem.html#load">load</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cmconstr.html#load">load</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.PPCgen.html#loadimm">loadimm</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#loadind">loadind</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#loadind_aux">loadind_aux</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Mem.html#loadv">loadv</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPC.html#load1">load1</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#load2">load2</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mem.html#load_contents">load_contents</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Values.html#load_result">load_result</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Mach.html#load_stack">load_stack</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.LTL.html#locset">locset</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Linear.html#locset">locset</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.Conventions.html#locs_acceptable">locs_acceptable</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Alloctyping.html#locs_read_ok">locs_read_ok</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Alloctyping.html#locs_write_ok">locs_write_ok</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Conventions.html#loc_acceptable">loc_acceptable</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments">loc_arguments</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_arguments_rec">loc_arguments_rec</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#loc_argument_acceptable">loc_argument_acceptable</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Coloring.html#loc_is_acceptable">loc_is_acceptable</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Conventions.html#loc_parameters">loc_parameters</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Alloctyping.html#loc_read_ok">loc_read_ok</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Conventions.html#loc_result">loc_result</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Alloctyping.html#loc_write_ok">loc_write_ok</a> [in <a href="backend.Alloctyping.html">backend.Alloctyping</a>]<br/>
-<a href="backend.Mem.html#low_bound">low_bound</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgen.html#low_s">low_s</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#low_u">low_u</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="lib.Integers.html#lt">lt</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Ordered.html#lt">lt</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt">lt</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#lt">lt</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Integers.html#ltu">ltu</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Lattice.html#lub">lub</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#lub">lub</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Sets.html#lub">lub</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Lattice.html#lub">lub</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Constprop.html#lub">lub</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<br/><br/><a name="definition_M"></a><h2>M </h2>
-<a href="backend.Constprop.html#make_addimm">make_addimm</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#make_andimm">make_andimm</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cminorgen.html#make_cast">make_cast</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Stacking.html#make_env">make_env</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Cminorgen.html#make_load">make_load</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Constprop.html#make_mulimm">make_mulimm</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cminorgen.html#make_op">make_op</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Constprop.html#make_orimm">make_orimm</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Kildall.html#make_predecessors">make_predecessors</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Constprop.html#make_shlimm">make_shlimm</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#make_shrimm">make_shrimm</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#make_shruimm">make_shruimm</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Cminorgen.html#make_stackaddr">make_stackaddr</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#make_store">make_store</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Constprop.html#make_xorimm">make_xorimm</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Maps.html#map">map</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#map">map</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#map">map</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#map">map</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTLtyping.html#mapped">mapped</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLgenproof.html#match_return_outcome">match_return_outcome</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof.html#match_return_reg">match_return_reg</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_instrs">max_over_instrs</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_list">max_over_list</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_regs_of_funct">max_over_regs_of_funct</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_regs_of_instr">max_over_regs_of_instr</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_slots_of_funct">max_over_slots_of_funct</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#max_over_slots_of_instr">max_over_slots_of_instr</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="lib.Integers.html#max_signed">max_signed</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#max_unsigned">max_unsigned</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Sets.html#mem">mem</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.RTLtyping.html#member">member</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Mem.html#meminj">meminj</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#mem_chunk">mem_chunk</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Machabstr.html#mem_type">mem_type</a> [in <a href="backend.Machabstr.html">backend.Machabstr</a>]<br/>
-<a href="backend.Parallelmove.html#mesure">mesure</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Integers.html#min_signed">min_signed</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLtyping.html#mk_env">mk_env</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Integers.html#mods">mods</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#mods">mods</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#mods">mods</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#modu">modu</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#modu">modu</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#modu">modu</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#modulus">modulus</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#mod_aux">mod_aux</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.RTLgen.html#mon">mon</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="lib.Integers.html#mone">mone</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Parallelmove.html#Move">Move</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#Moves">Moves</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Lineartyping.html#mreg_bounded">mreg_bounded</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Locations.html#mreg_type">mreg_type</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Integers.html#mul">mul</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#mul">mul</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#mul">mul</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#mulf">mulf</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#mulf">mulf</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm">mulimm</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_base">mulimm_base</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mulimm_match">mulimm_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_match">mul_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#mul_match_aux">mul_match_aux</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.RTLgen.html#mutated_condexpr">mutated_condexpr</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#mutated_expr">mutated_expr</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgen.html#mutated_exprlist">mutated_exprlist</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof1.html#mutated_reg">mutated_reg</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<br/><br/><a name="definition_N"></a><h2>N </h2>
-<a href="lib.Inclusion.html#nat_le_bool">nat_le_bool</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Values.html#neg">neg</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#neg">neg</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.AST.html#negate_comparison">negate_comparison</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Op.html#negate_condition">negate_condition</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Values.html#negf">negf</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#negfloat">negfloat</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#negint">negint</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.RTLgen.html#new_reg">new_reg</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.PPC.html#nextinstr">nextinstr</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#nil">nil</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#nil">nil</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTL.html#node">node</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.LTL.html#node">node</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Parallelmove.html#NoOverlap">NoOverlap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap">noOverlap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noOverlap_aux">noOverlap_aux</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noRead">noRead</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Integers.html#not">not</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#notbool">notbool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#notbool">notbool</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#notbool">notbool</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#notbool_base">notbool_base</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Parallelmove.html#notemporary">notemporary</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#notin">notin</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Values.html#notint">notint</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#notint">notint</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#notint_match">notint_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Parallelmove.html#noTmp">noTmp</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noTmpLast">noTmpLast</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#noWrite">noWrite</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#no_overlap">no_overlap</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Locations.html#no_overlap">no_overlap</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#no_overlap_list">no_overlap_list</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#no_overlap_state">no_overlap_state</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_overlap_stateD">no_overlap_stateD</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#no_tmp13_state">no_tmp13_state</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Mem.html#nullptr">nullptr</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.CSE.html#numbering_holds">numbering_holds</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#numbering_satisfiable">numbering_satisfiable</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Kildall.html#num_iterations">num_iterations</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<br/><br/><a name="definition_O"></a><h2>O </h2>
-<a href="backend.Stacking.html#offset_of_index">offset_of_index</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Op.html#offset_sp">offset_sp</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Values.html#of_bool">of_bool</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#one">one</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#one_bits">one_bits</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.RTLtyping.html#option_fold2">option_fold2</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Coqlib.html#option_map">option_map</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction">op_strength_reduction</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Constprop.html#op_strength_reduction_match">op_strength_reduction_match</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Integers.html#or">or</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#or">or</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#or">or</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.InterfGraph.html#ordered_pair">ordered_pair</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.PPCgen.html#orimm">orimm</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Cmconstr.html#or_match">or_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Csharpminor.html#outcome_block">outcome_block</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Cminor.html#outcome_block">outcome_block</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.RTLgenproof.html#outcome_node">outcome_node</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.Cminor.html#outcome_result_value">outcome_result_value</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Csharpminor.html#outcome_result_value">outcome_result_value</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Lineartyping.html#outgoing_slot">outgoing_slot</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#outgoing_space">outgoing_space</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Locations.html#overlap">overlap</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#overlap_aux">overlap_aux</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<br/><br/><a name="definition_P"></a><h2>P </h2>
-<a href="backend.Allocation.html#parallel_move">parallel_move</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#parallel_move_order">parallel_move_order</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Conventions.html#parameter_of_argument">parameter_of_argument</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Parallelmove.html#path">path</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Coqlib.html#peq">peq</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Parallelmove.html#pexec">pexec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Coqlib.html#Ple">Ple</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#Plt">Plt</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#plt">plt</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.Parallelmove.html#Pmov">Pmov</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Coqlib.html#positive_rec">positive_rec</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#powerserie">powerserie</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Kildall.html#predecessors">predecessors</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.PPCgenproof1.html#preg_of">preg_of</a> [in <a href="backend.PPCgenproof1.html">backend.PPCgenproof1</a>]<br/>
-<a href="backend.LTL.html#program">program</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Cminor.html#program">program</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Linear.html#program">program</a> [in <a href="backend.Linear.html">backend.Linear</a>]<br/>
-<a href="backend.RTL.html#program">program</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.Csharpminor.html#program">program</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.PPC.html#program">program</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mach.html#program">program</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ">propagate_succ</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_successors">propagate_successors</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#propagate_succ_list">propagate_succ_list</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#Pstate">Pstate</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Allocproof_aux.html#p_move">p_move</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Parallelmove.html#P_move">P_move</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<br/><br/><a name="definition_R"></a><h2>R </h2>
-<a href="backend.Coloring.html#R">R</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Linearize.html#reachable">reachable</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Linearize.html#reachable_aux">reachable_aux</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Registers.html#reg">reg</a> [in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Parallelmove.html#Reg">Reg</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Coloring.html#regalloc">regalloc</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.RTLtyping.html#regenv">regenv</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.LTL.html#reglist">reglist</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.Registers.html#regmap_optget">regmap_optget</a> [in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Registers.html#regmap_optset">regmap_optset</a> [in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Mach.html#regset">regset</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.RTL.html#regset">regset</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.PPC.html#regset">regset</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Allocation.html#regs_for">regs_for</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#regs_for_rec">regs_for_rec</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Constpropproof.html#regs_match_approx">regs_match_approx</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Lineartyping.html#regs_of_instr">regs_of_instr</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Allocation.html#reg_for">reg_for</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_fresh">reg_fresh</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_in_map">reg_in_map</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Allocation.html#reg_list_dead">reg_list_dead</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#reg_list_live">reg_list_live</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.PPC.html#reg_of_crbit">reg_of_crbit</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Allocation.html#reg_option_live">reg_option_live</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Allocation.html#reg_sum_live">reg_sum_live</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.RTLgenproof1.html#reg_valid">reg_valid</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.CSE.html#reg_valnum">reg_valnum</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="lib.Sets.html#remove">remove</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#remove">remove</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Inclusion.html#remove_all_leaves">remove_all_leaves</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.RTLtyping.html#repet">repet</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Parallelmove.html#replace_last_s">replace_last_s</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.union_find.html#repr">repr</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.Integers.html#repr">repr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.union_find.html#repr_aux">repr_aux</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_order">repr_order</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#repr_rec">repr_rec</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.RTLgen.html#reserve_instr">reserve_instr</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Stacking.html#restore_callee_save">restore_callee_save</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#restore_float_callee_save">restore_float_callee_save</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#restore_int_callee_save">restore_int_callee_save</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Kildall.html#result">result</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Allocproof_aux.html#reswellFormed">reswellFormed</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.RTLgen.html#ret">ret</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.LTL.html#return_regs">return_regs</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.RTLgen.html#ret_reg">ret_reg</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.CSEproof.html#rhs_evals_to">rhs_evals_to</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Parallelmove.html#right">right</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Integers.html#rlw_accepting">rlw_accepting</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rlw_transition">rlw_transition</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#rol">rol</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#rolm">rolm</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#rolm">rolm</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#rolm">rolm</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#rolm_match">rolm_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<br/><br/><a name="definition_S"></a><h2>S </h2>
-<a href="lib.union_find.html#sameclass">sameclass</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#sameclass">sameclass</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.Parallelmove.html#sameEnv">sameEnv</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#sameExec">sameExec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cmconstr.html#same_expr_pure">same_expr_pure</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Coloring.html#same_typ">same_typ</a> [in <a href="backend.Coloring.html">backend.Coloring</a>]<br/>
-<a href="backend.Stacking.html#save_callee_save">save_callee_save</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#save_float_callee_save">save_float_callee_save</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#save_int_callee_save">save_int_callee_save</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="lib.Maps.html#set">set</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#set">set</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#set">set</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#set">set</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#set">set</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Maps.html#set">set</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Mem.html#setN">setN</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#set_cont">set_cont</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminor.html#set_locals">set_locals</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Cminor.html#set_params">set_params</a> [in <a href="backend.Cminor.html">backend.Cminor</a>]<br/>
-<a href="backend.Parallelmove.html#Sexec">Sexec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#sexec">sexec</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cmconstr.html#shift_match">shift_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Stackingproof.html#shift_sp">shift_sp</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="lib.Integers.html#shl">shl</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#shl">shl</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#shl">shl</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#shlimm">shlimm</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#shr">shr</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#shr">shr</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#shr">shr</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#shru">shru</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#shru">shru</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shru">shru</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#shruimm">shruimm</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="lib.Integers.html#shrx">shrx</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Values.html#shrx">shrx</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#shr_carry">shr_carry</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#shr_carry">shr_carry</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#signed">signed</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Parallelmove.html#simpleDest">simpleDest</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Values.html#singleoffloat">singleoffloat</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#singleoffloat">singleoffloat</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Csharpminor.html#sizeof">sizeof</a> [in <a href="backend.Csharpminor.html">backend.Csharpminor</a>]<br/>
-<a href="backend.Conventions.html#size_arguments">size_arguments</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Conventions.html#size_arguments_rec">size_arguments_rec</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Mem.html#size_chunk">size_chunk</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Mem.html#size_mem">size_mem</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Lineartyping.html#slots_of_instr">slots_of_instr</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Lineartyping.html#slot_bounded">slot_bounded</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.LTLtyping.html#slot_bounded">slot_bounded</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.Locations.html#slot_type">slot_type</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Parallelmove.html#Some">Some</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Inclusion.html#sort_bin">sort_bin</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Parallelmove.html#split_move">split_move</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#split_move'">split_move'</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Linearize.html#starts_with">starts_with</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Kildall.html#start_state">start_state</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#start_state_in">start_state_in</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#start_state_wrk">start_state_wrk</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#State">State</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#StateBeing">StateBeing</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#StateDone">StateDone</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#StateToMove">StateToMove</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLgenproof1.html#state_extends">state_extends</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Kildall.html#state_invariant">state_invariant</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#step">step</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#step">step</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Parallelmove.html#stepf">stepf</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepf'">stepf'</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#stepInv">stepInv</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Parallelmove.html#step_NF">step_NF</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.Cmconstr.html#store">store</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Mem.html#store">store</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPCgen.html#storeind">storeind</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.PPCgen.html#storeind_aux">storeind_aux</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Mem.html#storev">storev</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.PPC.html#store1">store1</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#store2">store2</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Mem.html#store_contents">store_contents</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Cminorgen.html#store_parameters">store_parameters</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Mach.html#store_stack">store_stack</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Values.html#sub">sub</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#sub">sub</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Cmconstr.html#sub">sub</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#subf">subf</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Cmconstr.html#subf">subf</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#subf_match">subf_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_match">sub_match</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Cmconstr.html#sub_match_aux">sub_match_aux</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.LTL.html#successors">successors</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="backend.RTL.html#successors">successors</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.LTL.html#successors_aux">successors_aux</a> [in <a href="backend.LTL.html">backend.LTL</a>]<br/>
-<a href="lib.Coqlib.html#sum_left_map">sum_left_map</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="backend.AST.html#swap_comparison">swap_comparison</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.PPC.html#symbol_offset">symbol_offset</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Linearize.html#s1">s1</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<br/><br/><a name="definition_T"></a><h2>T </h2>
-<a href="backend.PPC.html#t">t</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Ordered.html#t">t</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Lattice.html#t">t</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Locations.html#t">t</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Constprop.html#t">t</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Ordered.html#t">t</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.Globalenvs.html#t">t</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="lib.Lattice.html#t">t</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.RTLtyping.html#T">T</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.union_find.html#T">T</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.CSEproof.html#t">t</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.Locations.html#t">t</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Parallelmove.html#T">T</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.RTLtyping.html#T">T</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.InterfGraph.html#t">t</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Ordered.html#t">t</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Lattice.html#t">t</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Mach.html#t">t</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="lib.Sets.html#t">t</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#t">t</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.CSE.html#t">t</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Conventions.html#temporaries">temporaries</a> [in <a href="backend.Conventions.html">backend.Conventions</a>]<br/>
-<a href="backend.Allocproof_aux.html#temporaries1">temporaries1</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#temporaries1_3">temporaries1_3</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.Allocproof_aux.html#temporaries2">temporaries2</a> [in <a href="backend.Allocproof_aux.html">backend.Allocproof_aux</a>]<br/>
-<a href="backend.RTLtyping.html#teq">teq</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.Inclusion.html#test_inclusion">test_inclusion</a> [in <a href="lib.Inclusion.html">lib.Inclusion</a>]<br/>
-<a href="backend.Allocation.html#Tint">Tint</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="lib.Lattice.html#top">top</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#top">top</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.CSE.html#top">top</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Constprop.html#top">top</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="lib.Lattice.html#top">top</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Allocation.html#transfer">transfer</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Constprop.html#transfer">transfer</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.CSE.html#transfer">transfer</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.AST.html#transform_partial_program">transform_partial_program</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.AST.html#transform_program">transform_program</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Main.html#transf_cminor_function">transf_cminor_function</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program">transf_cminor_program</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_cminor_program2">transf_cminor_program2</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Constprop.html#transf_code">transf_code</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.CSE.html#transf_code">transf_code</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_function">transf_csharpminor_function</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program">transf_csharpminor_program</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Main.html#transf_csharpminor_program2">transf_csharpminor_program2</a> [in <a href="backend.Main.html">backend.Main</a>]<br/>
-<a href="backend.Allocation.html#transf_entrypoint">transf_entrypoint</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Linearize.html#transf_function">transf_function</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Allocation.html#transf_function">transf_function</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.CSE.html#transf_function">transf_function</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.RTL.html#transf_function">transf_function</a> [in <a href="backend.RTL.html">backend.RTL</a>]<br/>
-<a href="backend.PPCgen.html#transf_function">transf_function</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Stacking.html#transf_function">transf_function</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Constprop.html#transf_function">transf_function</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Allocation.html#transf_instr">transf_instr</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Constprop.html#transf_instr">transf_instr</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.CSE.html#transf_instr">transf_instr</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Globalenvs.html#transf_partial">transf_partial</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.AST.html#transf_partial_program">transf_partial_program</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.CSE.html#transf_program">transf_program</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.PPCgen.html#transf_program">transf_program</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Stacking.html#transf_program">transf_program</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Constprop.html#transf_program">transf_program</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Allocation.html#transf_program">transf_program</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<a href="backend.Linearize.html#transf_program">transf_program</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.AST.html#transf_program">transf_program</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Stacking.html#transl_addr">transl_addr</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.Stacking.html#transl_body">transl_body</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.PPCgen.html#transl_code">transl_code</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Stacking.html#transl_code">transl_code</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.PPCgen.html#transl_cond">transl_cond</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_condition_correct">transl_condition_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_condition_incr_pred">transl_condition_incr_pred</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#transl_expr">transl_expr</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Cminorgen.html#transl_expr">transl_expr</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_exprlist_correct">transl_exprlist_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_exprlist_incr_pred">transl_exprlist_incr_pred</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_expr_correct">transl_expr_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_expr_incr_pred">transl_expr_incr_pred</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgen.html#transl_fun">transl_fun</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Cminorgen.html#transl_function">transl_function</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.PPCgen.html#transl_function">transl_function</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.RTLgen.html#transl_function">transl_function</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_function_correct">transl_function_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.PPCgen.html#transl_instr">transl_instr</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Stacking.html#transl_instr">transl_instr</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.PPCgen.html#transl_load_store">transl_load_store</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.Stacking.html#transl_op">transl_op</a> [in <a href="backend.Stacking.html">backend.Stacking</a>]<br/>
-<a href="backend.PPCgen.html#transl_op">transl_op</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<a href="backend.RTLgen.html#transl_program">transl_program</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.Cminorgen.html#transl_program">transl_program</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#transl_stmt">transl_stmt</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.RTLgen.html#transl_stmt">transl_stmt</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmtlist_correct">transl_stmtlist_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmtlist_incr_pred">transl_stmtlist_incr_pred</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.RTLgenproof.html#transl_stmt_correct">transl_stmt_correct</a> [in <a href="backend.RTLgenproof.html">backend.RTLgenproof</a>]<br/>
-<a href="backend.RTLgenproof1.html#transl_stmt_incr_pred">transl_stmt_incr_pred</a> [in <a href="backend.RTLgenproof1.html">backend.RTLgenproof1</a>]<br/>
-<a href="backend.Tunnelingproof.html#tunneled_code">tunneled_code</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Tunneling.html#tunnel_block">tunnel_block</a> [in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Tunneling.html#tunnel_function">tunnel_function</a> [in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Tunnelingproof.html#tunnel_outcome">tunnel_outcome</a> [in <a href="backend.Tunnelingproof.html">backend.Tunnelingproof</a>]<br/>
-<a href="backend.Tunneling.html#tunnel_program">tunnel_program</a> [in <a href="backend.Tunneling.html">backend.Tunneling</a>]<br/>
-<a href="backend.Locations.html#type">type</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Registers.html#typenv">typenv</a> [in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.AST.html#typesize">typesize</a> [in <a href="backend.AST.html">backend.AST</a>]<br/>
-<a href="backend.Locations.html#typesize">typesize</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Op.html#type_of_addressing">type_of_addressing</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#type_of_chunk">type_of_chunk</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Op.html#type_of_condition">type_of_condition</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.Stackingproof.html#type_of_index">type_of_index</a> [in <a href="backend.Stackingproof.html">backend.Stackingproof</a>]<br/>
-<a href="backend.Op.html#type_of_operation">type_of_operation</a> [in <a href="backend.Op.html">backend.Op</a>]<br/>
-<a href="backend.RTLtyping.html#type_of_sig_res">type_of_sig_res</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_arg">type_rtl_arg</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_function">type_rtl_function</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_instr">type_rtl_instr</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#type_rtl_ros">type_rtl_ros</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<br/><br/><a name="definition_U"></a><h2>U </h2>
-<a href="backend.Mem.html#unchecked_store">unchecked_store</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Sets.html#union">union</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="backend.Linearizeproof.html#unique_labels">unique_labels</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="lib.Integers.html#unsigned">unsigned</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Mem.html#update">update</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Parallelmove.html#update">update</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.RTLgen.html#update_instr">update_instr</a> [in <a href="backend.RTLgen.html">backend.RTLgen</a>]<br/>
-<br/><br/><a name="definition_V"></a><h2>V </h2>
-<a href="backend.Mem.html#valid_block">valid_block</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.Linearizeproof.html#valid_outcome">valid_outcome</a> [in <a href="backend.Linearizeproof.html">backend.Linearizeproof</a>]<br/>
-<a href="backend.Mem.html#valid_pointer">valid_pointer</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="backend.CSE.html#valnum">valnum</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#valnum_reg">valnum_reg</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.CSE.html#valnum_regs">valnum_regs</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<a href="backend.Parallelmove.html#Value">Value</a> [in <a href="backend.Parallelmove.html">backend.Parallelmove</a>]<br/>
-<a href="backend.CSEproof.html#valu_agree">valu_agree</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.PPC.html#val_cond_reg">val_cond_reg</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.Constpropproof.html#val_match_approx">val_match_approx</a> [in <a href="backend.Constpropproof.html">backend.Constpropproof</a>]<br/>
-<a href="backend.Cminorgenproof.html#val_normalized">val_normalized</a> [in <a href="backend.Cminorgenproof.html">backend.Cminorgenproof</a>]<br/>
-<a href="backend.Cminorgen.html#var_addr">var_addr</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#var_get">var_get</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Cminorgen.html#var_set">var_set</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="backend.Values.html#Vfalse">Vfalse</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vmone">Vmone</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vone">Vone</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vtrue">Vtrue</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.Values.html#Vzero">Vzero</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<br/><br/><a name="definition_W"></a><h2>W </h2>
-<a href="backend.CSEproof.html#wf_equation">wf_equation</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_numbering">wf_numbering</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#wf_rhs">wf_rhs</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="lib.Integers.html#wordsize">wordsize</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Machtyping.html#wt_content">wt_content</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_frame">wt_frame</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_function">wt_function</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_function">wt_function</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.Stackingtyping.html#wt_instrs">wt_instrs</a> [in <a href="backend.Stackingtyping.html">backend.Stackingtyping</a>]<br/>
-<a href="backend.Lineartyping.html#wt_program">wt_program</a> [in <a href="backend.Lineartyping.html">backend.Lineartyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_program">wt_program</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.LTLtyping.html#wt_program">wt_program</a> [in <a href="backend.LTLtyping.html">backend.LTLtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_program">wt_program</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<a href="backend.RTLtyping.html#wt_regset">wt_regset</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.Machtyping.html#wt_regset">wt_regset</a> [in <a href="backend.Machtyping.html">backend.Machtyping</a>]<br/>
-<br/><br/><a name="definition_X"></a><h2>X </h2>
-<a href="lib.Maps.html#xcombine_l">xcombine_l</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xcombine_r">xcombine_r</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xelements">xelements</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xget">xget</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xkeys">xkeys</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#xmap">xmap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Cmconstr.html#xor">xor</a> [in <a href="backend.Cmconstr.html">backend.Cmconstr</a>]<br/>
-<a href="backend.Values.html#xor">xor</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="lib.Integers.html#xor">xor</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.PPCgen.html#xorimm">xorimm</a> [in <a href="backend.PPCgen.html">backend.PPCgen</a>]<br/>
-<br/><br/><a name="definition_Z"></a><h2>Z </h2>
-<a href="lib.Integers.html#Zdiv_round">Zdiv_round</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Coqlib.html#zeq">zeq</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#zero">zero</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Coqlib.html#zle">zle</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Coqlib.html#zlt">zlt</a> [in <a href="lib.Coqlib.html">lib.Coqlib</a>]<br/>
-<a href="lib.Integers.html#Zmod_round">Zmod_round</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="backend.Mem.html#ztonat">ztonat</a> [in <a href="backend.Mem.html">backend.Mem</a>]<br/>
-<a href="lib.Integers.html#Z_bin_decomp">Z_bin_decomp</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_of_bits">Z_of_bits</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_one_bits">Z_one_bits</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<a href="lib.Integers.html#Z_shift_add">Z_shift_add</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<br/><br/><hr/>
-<h1>Module Index</h1>
-<a name="module_A"></a><h2>A </h2>
-<a href="backend.Constprop.html#Approx">Approx</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<br/><br/><a name="module_B"></a><h2>B </h2>
-<a href="backend.Kildall.html#BACKWARD_DATAFLOW_SOLVER">BACKWARD_DATAFLOW_SOLVER</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#Backward_Dataflow_Solver">Backward_Dataflow_Solver</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#BBlock_solver">BBlock_solver</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#BBLOCK_SOLVER">BBLOCK_SOLVER</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<br/><br/><a name="module_D"></a><h2>D </h2>
-<a href="backend.Constprop.html#D">D</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Kildall.html#Dataflow_Solver">Dataflow_Solver</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#DATAFLOW_SOLVER">DATAFLOW_SOLVER</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#DS">DS</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Constprop.html#DS">DS</a> [in <a href="backend.Constprop.html">backend.Constprop</a>]<br/>
-<a href="backend.Linearize.html#DS">DS</a> [in <a href="backend.Linearize.html">backend.Linearize</a>]<br/>
-<a href="backend.Allocation.html#DS">DS</a> [in <a href="backend.Allocation.html">backend.Allocation</a>]<br/>
-<br/><br/><a name="module_E"></a><h2>E </h2>
-<a href="lib.union_find.html#ELEMENT">ELEMENT</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.Maps.html#EMap">EMap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#EQUALITY_TYPE">EQUALITY_TYPE</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<br/><br/><a name="module_F"></a><h2>F </h2>
-<a href="lib.Floats.html#Float">Float</a> [in <a href="lib.Floats.html">lib.Floats</a>]<br/>
-<br/><br/><a name="module_G"></a><h2>G </h2>
-<a href="backend.Globalenvs.html#Genv">Genv</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<a href="backend.Globalenvs.html#GENV">GENV</a> [in <a href="backend.Globalenvs.html">backend.Globalenvs</a>]<br/>
-<br/><br/><a name="module_I"></a><h2>I </h2>
-<a href="backend.Cminorgen.html#Identset">Identset</a> [in <a href="backend.Cminorgen.html">backend.Cminorgen</a>]<br/>
-<a href="lib.Maps.html#IMap">IMap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.Locations.html#IndexedMreg">IndexedMreg</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Maps.html#INDEXED_TYPE">INDEXED_TYPE</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Integers.html#Int">Int</a> [in <a href="lib.Integers.html">lib.Integers</a>]<br/>
-<br/><br/><a name="module_L"></a><h2>L </h2>
-<a href="backend.Kildall.html#L">L</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="backend.Kildall.html#L">L</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<a href="lib.Lattice.html#LBoolean">LBoolean</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#LFlat">LFlat</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.Locations.html#Loc">Loc</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="backend.Locations.html#Locmap">Locmap</a> [in <a href="backend.Locations.html">backend.Locations</a>]<br/>
-<a href="lib.Lattice.html#LPMap">LPMap</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<br/><br/><a name="module_M"></a><h2>M </h2>
-<a href="lib.Sets.html#MakeSet">MakeSet</a> [in <a href="lib.Sets.html">lib.Sets</a>]<br/>
-<a href="lib.Maps.html#MAP">MAP</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.union_find.html#MAP">MAP</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="backend.RTLtyping.html#mymap">mymap</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="backend.RTLtyping.html#myreg">myreg</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<br/><br/><a name="module_N"></a><h2>N </h2>
-<a href="lib.Maps.html#NIndexed">NIndexed</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#NMap">NMap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.CSE.html#Numbering">Numbering</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<br/><br/><a name="module_O"></a><h2>O </h2>
-<a href="lib.Ordered.html#OrderedIndexed">OrderedIndexed</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.InterfGraph.html#OrderedMreg">OrderedMreg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="lib.Ordered.html#OrderedPair">OrderedPair</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="lib.Ordered.html#OrderedPositive">OrderedPositive</a> [in <a href="lib.Ordered.html">lib.Ordered</a>]<br/>
-<a href="backend.InterfGraph.html#OrderedReg">OrderedReg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#OrderedRegMreg">OrderedRegMreg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#OrderedRegReg">OrderedRegReg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.Kildall.html#ORDERED_TYPE_WITH_TOP">ORDERED_TYPE_WITH_TOP</a> [in <a href="backend.Kildall.html">backend.Kildall</a>]<br/>
-<br/><br/><a name="module_P"></a><h2>P </h2>
-<a href="lib.Maps.html#PMap">PMap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="backend.PPC.html#PregEq">PregEq</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="backend.PPC.html#Pregmap">Pregmap</a> [in <a href="backend.PPC.html">backend.PPC</a>]<br/>
-<a href="lib.Maps.html#PTree">PTree</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<br/><br/><a name="module_R"></a><h2>R </h2>
-<a href="backend.Registers.html#Reg">Reg</a> [in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Mach.html#RegEq">RegEq</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Mach.html#Regmap">Regmap</a> [in <a href="backend.Mach.html">backend.Mach</a>]<br/>
-<a href="backend.Registers.html#Regmap">Regmap</a> [in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<a href="backend.Registers.html#Regset">Regset</a> [in <a href="backend.Registers.html">backend.Registers</a>]<br/>
-<br/><br/><a name="module_S"></a><h2>S </h2>
-<a href="lib.Lattice.html#SEMILATTICE">SEMILATTICE</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="lib.Lattice.html#SEMILATTICE_WITH_TOP">SEMILATTICE_WITH_TOP</a> [in <a href="lib.Lattice.html">lib.Lattice</a>]<br/>
-<a href="backend.InterfGraph.html#SetDepRegMreg">SetDepRegMreg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#SetDepRegReg">SetDepRegReg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#SetRegMreg">SetRegMreg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.InterfGraph.html#SetRegReg">SetRegReg</a> [in <a href="backend.InterfGraph.html">backend.InterfGraph</a>]<br/>
-<a href="backend.CSE.html#Solver">Solver</a> [in <a href="backend.CSE.html">backend.CSE</a>]<br/>
-<br/><br/><a name="module_T"></a><h2>T </h2>
-<a href="lib.Maps.html#TREE">TREE</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<br/><br/><a name="module_U"></a><h2>U </h2>
-<a href="backend.RTLtyping.html#Uf">Uf</a> [in <a href="backend.RTLtyping.html">backend.RTLtyping</a>]<br/>
-<a href="lib.union_find.html#UNIONFIND">UNIONFIND</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<a href="lib.union_find.html#Unionfind">Unionfind</a> [in <a href="lib.union_find.html">lib.union_find</a>]<br/>
-<br/><br/><a name="module_V"></a><h2>V </h2>
-<a href="backend.Values.html#Val">Val</a> [in <a href="backend.Values.html">backend.Values</a>]<br/>
-<a href="backend.CSEproof.html#ValnumEq">ValnumEq</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<a href="backend.CSEproof.html#VMap">VMap</a> [in <a href="backend.CSEproof.html">backend.CSEproof</a>]<br/>
-<br/><br/><a name="module_Z"></a><h2>Z </h2>
-<a href="lib.Maps.html#ZIndexed">ZIndexed</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<a href="lib.Maps.html#ZMap">ZMap</a> [in <a href="lib.Maps.html">lib.Maps</a>]<br/>
-<br/><br/><hr/>
-<h1>Library Index</h1>
-<a name="library_A"></a><h2>A </h2>
-<a href="backend.Allocation.html">Allocation</a> <br/>
-<a href="backend.Allocproof.html">Allocproof</a> <br/>
-<a href="backend.Allocproof_aux.html">Allocproof_aux</a> <br/>
-<a href="backend.Alloctyping.html">Alloctyping</a> <br/>
-<a href="backend.Alloctyping_aux.html">Alloctyping_aux</a> <br/>
-<a href="backend.AST.html">AST</a> <br/>
-<br/><br/><a name="library_C"></a><h2>C </h2>
-<a href="backend.Cmconstr.html">Cmconstr</a> <br/>
-<a href="backend.Cmconstrproof.html">Cmconstrproof</a> <br/>
-<a href="backend.Cminor.html">Cminor</a> <br/>
-<a href="backend.Cminorgen.html">Cminorgen</a> <br/>
-<a href="backend.Cminorgenproof.html">Cminorgenproof</a> <br/>
-<a href="backend.Coloring.html">Coloring</a> <br/>
-<a href="backend.Coloringproof.html">Coloringproof</a> <br/>
-<a href="backend.Constprop.html">Constprop</a> <br/>
-<a href="backend.Constpropproof.html">Constpropproof</a> <br/>
-<a href="backend.Conventions.html">Conventions</a> <br/>
-<a href="lib.Coqlib.html">Coqlib</a> <br/>
-<a href="backend.CSE.html">CSE</a> <br/>
-<a href="backend.CSEproof.html">CSEproof</a> <br/>
-<a href="backend.Csharpminor.html">Csharpminor</a> <br/>
-<br/><br/><a name="library_F"></a><h2>F </h2>
-<a href="lib.Floats.html">Floats</a> <br/>
-<br/><br/><a name="library_G"></a><h2>G </h2>
-<a href="backend.Globalenvs.html">Globalenvs</a> <br/>
-<br/><br/><a name="library_I"></a><h2>I </h2>
-<a href="lib.Inclusion.html">Inclusion</a> <br/>
-<a href="lib.Integers.html">Integers</a> <br/>
-<a href="backend.InterfGraph.html">InterfGraph</a> <br/>
-<br/><br/><a name="library_K"></a><h2>K </h2>
-<a href="backend.Kildall.html">Kildall</a> <br/>
-<br/><br/><a name="library_L"></a><h2>L </h2>
-<a href="lib.Lattice.html">Lattice</a> <br/>
-<a href="backend.Linear.html">Linear</a> <br/>
-<a href="backend.Linearize.html">Linearize</a> <br/>
-<a href="backend.Linearizeproof.html">Linearizeproof</a> <br/>
-<a href="backend.Linearizetyping.html">Linearizetyping</a> <br/>
-<a href="backend.Lineartyping.html">Lineartyping</a> <br/>
-<a href="backend.Locations.html">Locations</a> <br/>
-<a href="backend.LTL.html">LTL</a> <br/>
-<a href="backend.LTLtyping.html">LTLtyping</a> <br/>
-<br/><br/><a name="library_M"></a><h2>M </h2>
-<a href="backend.Mach.html">Mach</a> <br/>
-<a href="backend.Machabstr.html">Machabstr</a> <br/>
-<a href="backend.Machabstr2mach.html">Machabstr2mach</a> <br/>
-<a href="backend.Machtyping.html">Machtyping</a> <br/>
-<a href="backend.Main.html">Main</a> <br/>
-<a href="lib.Maps.html">Maps</a> <br/>
-<a href="backend.Mem.html">Mem</a> <br/>
-<br/><br/><a name="library_O"></a><h2>O </h2>
-<a href="backend.Op.html">Op</a> <br/>
-<a href="lib.Ordered.html">Ordered</a> <br/>
-<br/><br/><a name="library_P"></a><h2>P </h2>
-<a href="backend.Parallelmove.html">Parallelmove</a> <br/>
-<a href="backend.PPC.html">PPC</a> <br/>
-<a href="backend.PPCgen.html">PPCgen</a> <br/>
-<a href="backend.PPCgenproof.html">PPCgenproof</a> <br/>
-<a href="backend.PPCgenproof1.html">PPCgenproof1</a> <br/>
-<br/><br/><a name="library_R"></a><h2>R </h2>
-<a href="backend.Registers.html">Registers</a> <br/>
-<a href="backend.RTL.html">RTL</a> <br/>
-<a href="backend.RTLgen.html">RTLgen</a> <br/>
-<a href="backend.RTLgenproof.html">RTLgenproof</a> <br/>
-<a href="backend.RTLgenproof1.html">RTLgenproof1</a> <br/>
-<a href="backend.RTLtyping.html">RTLtyping</a> <br/>
-<br/><br/><a name="library_S"></a><h2>S </h2>
-<a href="lib.Sets.html">Sets</a> <br/>
-<a href="backend.Stacking.html">Stacking</a> <br/>
-<a href="backend.Stackingproof.html">Stackingproof</a> <br/>
-<a href="backend.Stackingtyping.html">Stackingtyping</a> <br/>
-<br/><br/><a name="library_T"></a><h2>T </h2>
-<a href="backend.Tunneling.html">Tunneling</a> <br/>
-<a href="backend.Tunnelingproof.html">Tunnelingproof</a> <br/>
-<a href="backend.Tunnelingtyping.html">Tunnelingtyping</a> <br/>
-<br/><br/><a name="library_U"></a><h2>U </h2>
-<a href="lib.union_find.html">union_find</a> <br/>
-<br/><br/><a name="library_V"></a><h2>V </h2>
-<a href="backend.Values.html">Values</a> <br/>
-<br/><br/><hr/><table>
-<tr>
-<td>Global Index</td>
-<td><a href="index.html#global_A">A</a></td>
-<td><a href="index.html#global_B">B</a></td>
-<td><a href="index.html#global_C">C</a></td>
-<td><a href="index.html#global_D">D</a></td>
-<td><a href="index.html#global_E">E</a></td>
-<td><a href="index.html#global_F">F</a></td>
-<td><a href="index.html#global_G">G</a></td>
-<td><a href="index.html#global_H">H</a></td>
-<td><a href="index.html#global_I">I</a></td>
-<td>J</td>
-<td><a href="index.html#global_K">K</a></td>
-<td><a href="index.html#global_L">L</a></td>
-<td><a href="index.html#global_M">M</a></td>
-<td><a href="index.html#global_N">N</a></td>
-<td><a href="index.html#global_O">O</a></td>
-<td><a href="index.html#global_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#global_R">R</a></td>
-<td><a href="index.html#global_S">S</a></td>
-<td><a href="index.html#global_T">T</a></td>
-<td><a href="index.html#global_U">U</a></td>
-<td><a href="index.html#global_V">V</a></td>
-<td><a href="index.html#global_W">W</a></td>
-<td><a href="index.html#global_X">X</a></td>
-<td>Y</td>
-<td><a href="index.html#global_Z">Z</a></td>
-<td><a href="index.html#global__">_</a></td>
-<td>(3806 entries)</td>
-</tr>
-<tr>
-<td>Axiom Index</td>
-<td><a href="index.html#axiom_A">A</a></td>
-<td>B</td>
-<td><a href="index.html#axiom_C">C</a></td>
-<td><a href="index.html#axiom_D">D</a></td>
-<td><a href="index.html#axiom_E">E</a></td>
-<td><a href="index.html#axiom_F">F</a></td>
-<td><a href="index.html#axiom_G">G</a></td>
-<td><a href="index.html#axiom_H">H</a></td>
-<td><a href="index.html#axiom_I">I</a></td>
-<td>J</td>
-<td>K</td>
-<td><a href="index.html#axiom_L">L</a></td>
-<td><a href="index.html#axiom_M">M</a></td>
-<td><a href="index.html#axiom_N">N</a></td>
-<td><a href="index.html#axiom_O">O</a></td>
-<td><a href="index.html#axiom_P">P</a></td>
-<td>Q</td>
-<td>R</td>
-<td><a href="index.html#axiom_S">S</a></td>
-<td>T</td>
-<td>U</td>
-<td>V</td>
-<td>W</td>
-<td>X</td>
-<td>Y</td>
-<td><a href="index.html#axiom_Z">Z</a></td>
-<td>_</td>
-<td>(39 entries)</td>
-</tr>
-<tr>
-<td>Lemma Index</td>
-<td><a href="index.html#lemma_A">A</a></td>
-<td><a href="index.html#lemma_B">B</a></td>
-<td><a href="index.html#lemma_C">C</a></td>
-<td><a href="index.html#lemma_D">D</a></td>
-<td><a href="index.html#lemma_E">E</a></td>
-<td><a href="index.html#lemma_F">F</a></td>
-<td><a href="index.html#lemma_G">G</a></td>
-<td><a href="index.html#lemma_H">H</a></td>
-<td><a href="index.html#lemma_I">I</a></td>
-<td>J</td>
-<td><a href="index.html#lemma_K">K</a></td>
-<td><a href="index.html#lemma_L">L</a></td>
-<td><a href="index.html#lemma_M">M</a></td>
-<td><a href="index.html#lemma_N">N</a></td>
-<td><a href="index.html#lemma_O">O</a></td>
-<td><a href="index.html#lemma_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#lemma_R">R</a></td>
-<td><a href="index.html#lemma_S">S</a></td>
-<td><a href="index.html#lemma_T">T</a></td>
-<td><a href="index.html#lemma_U">U</a></td>
-<td><a href="index.html#lemma_V">V</a></td>
-<td><a href="index.html#lemma_W">W</a></td>
-<td><a href="index.html#lemma_X">X</a></td>
-<td>Y</td>
-<td><a href="index.html#lemma_Z">Z</a></td>
-<td>_</td>
-<td>(1753 entries)</td>
-</tr>
-<tr>
-<td>Constructor Index</td>
-<td><a href="index.html#constructor_A">A</a></td>
-<td><a href="index.html#constructor_B">B</a></td>
-<td><a href="index.html#constructor_C">C</a></td>
-<td><a href="index.html#constructor_D">D</a></td>
-<td><a href="index.html#constructor_E">E</a></td>
-<td><a href="index.html#constructor_F">F</a></td>
-<td><a href="index.html#constructor_G">G</a></td>
-<td>H</td>
-<td><a href="index.html#constructor_I">I</a></td>
-<td>J</td>
-<td>K</td>
-<td><a href="index.html#constructor_L">L</a></td>
-<td><a href="index.html#constructor_M">M</a></td>
-<td><a href="index.html#constructor_N">N</a></td>
-<td><a href="index.html#constructor_O">O</a></td>
-<td><a href="index.html#constructor_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#constructor_R">R</a></td>
-<td><a href="index.html#constructor_S">S</a></td>
-<td><a href="index.html#constructor_T">T</a></td>
-<td><a href="index.html#constructor_U">U</a></td>
-<td><a href="index.html#constructor_V">V</a></td>
-<td><a href="index.html#constructor_W">W</a></td>
-<td>X</td>
-<td>Y</td>
-<td>Z</td>
-<td><a href="index.html#constructor__">_</a></td>
-<td>(700 entries)</td>
-</tr>
-<tr>
-<td>Inductive Index</td>
-<td><a href="index.html#inductive_A">A</a></td>
-<td><a href="index.html#inductive_B">B</a></td>
-<td><a href="index.html#inductive_C">C</a></td>
-<td><a href="index.html#inductive_D">D</a></td>
-<td><a href="index.html#inductive_E">E</a></td>
-<td><a href="index.html#inductive_F">F</a></td>
-<td><a href="index.html#inductive_G">G</a></td>
-<td>H</td>
-<td><a href="index.html#inductive_I">I</a></td>
-<td>J</td>
-<td>K</td>
-<td><a href="index.html#inductive_L">L</a></td>
-<td><a href="index.html#inductive_M">M</a></td>
-<td><a href="index.html#inductive_N">N</a></td>
-<td><a href="index.html#inductive_O">O</a></td>
-<td><a href="index.html#inductive_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#inductive_R">R</a></td>
-<td><a href="index.html#inductive_S">S</a></td>
-<td><a href="index.html#inductive_T">T</a></td>
-<td><a href="index.html#inductive_U">U</a></td>
-<td><a href="index.html#inductive_V">V</a></td>
-<td><a href="index.html#inductive_W">W</a></td>
-<td>X</td>
-<td>Y</td>
-<td>Z</td>
-<td>_</td>
-<td>(155 entries)</td>
-</tr>
-<tr>
-<td>Definition Index</td>
-<td><a href="index.html#definition_A">A</a></td>
-<td><a href="index.html#definition_B">B</a></td>
-<td><a href="index.html#definition_C">C</a></td>
-<td><a href="index.html#definition_D">D</a></td>
-<td><a href="index.html#definition_E">E</a></td>
-<td><a href="index.html#definition_F">F</a></td>
-<td><a href="index.html#definition_G">G</a></td>
-<td><a href="index.html#definition_H">H</a></td>
-<td><a href="index.html#definition_I">I</a></td>
-<td>J</td>
-<td><a href="index.html#definition_K">K</a></td>
-<td><a href="index.html#definition_L">L</a></td>
-<td><a href="index.html#definition_M">M</a></td>
-<td><a href="index.html#definition_N">N</a></td>
-<td><a href="index.html#definition_O">O</a></td>
-<td><a href="index.html#definition_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#definition_R">R</a></td>
-<td><a href="index.html#definition_S">S</a></td>
-<td><a href="index.html#definition_T">T</a></td>
-<td><a href="index.html#definition_U">U</a></td>
-<td><a href="index.html#definition_V">V</a></td>
-<td><a href="index.html#definition_W">W</a></td>
-<td><a href="index.html#definition_X">X</a></td>
-<td>Y</td>
-<td><a href="index.html#definition_Z">Z</a></td>
-<td>_</td>
-<td>(1017 entries)</td>
-</tr>
-<tr>
-<td>Module Index</td>
-<td><a href="index.html#module_A">A</a></td>
-<td><a href="index.html#module_B">B</a></td>
-<td>C</td>
-<td><a href="index.html#module_D">D</a></td>
-<td><a href="index.html#module_E">E</a></td>
-<td><a href="index.html#module_F">F</a></td>
-<td><a href="index.html#module_G">G</a></td>
-<td>H</td>
-<td><a href="index.html#module_I">I</a></td>
-<td>J</td>
-<td>K</td>
-<td><a href="index.html#module_L">L</a></td>
-<td><a href="index.html#module_M">M</a></td>
-<td><a href="index.html#module_N">N</a></td>
-<td><a href="index.html#module_O">O</a></td>
-<td><a href="index.html#module_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#module_R">R</a></td>
-<td><a href="index.html#module_S">S</a></td>
-<td><a href="index.html#module_T">T</a></td>
-<td><a href="index.html#module_U">U</a></td>
-<td><a href="index.html#module_V">V</a></td>
-<td>W</td>
-<td>X</td>
-<td>Y</td>
-<td><a href="index.html#module_Z">Z</a></td>
-<td>_</td>
-<td>(78 entries)</td>
-</tr>
-<tr>
-<td>Library Index</td>
-<td><a href="index.html#library_A">A</a></td>
-<td>B</td>
-<td><a href="index.html#library_C">C</a></td>
-<td>D</td>
-<td>E</td>
-<td><a href="index.html#library_F">F</a></td>
-<td><a href="index.html#library_G">G</a></td>
-<td>H</td>
-<td><a href="index.html#library_I">I</a></td>
-<td>J</td>
-<td><a href="index.html#library_K">K</a></td>
-<td><a href="index.html#library_L">L</a></td>
-<td><a href="index.html#library_M">M</a></td>
-<td>N</td>
-<td><a href="index.html#library_O">O</a></td>
-<td><a href="index.html#library_P">P</a></td>
-<td>Q</td>
-<td><a href="index.html#library_R">R</a></td>
-<td><a href="index.html#library_S">S</a></td>
-<td><a href="index.html#library_T">T</a></td>
-<td><a href="index.html#library_U">U</a></td>
-<td><a href="index.html#library_V">V</a></td>
-<td>W</td>
-<td>X</td>
-<td>Y</td>
-<td>Z</td>
-<td>_</td>
-<td>(64 entries)</td>
-</tr>
-</table>
-<hr/><font size="-1">This page has been generated by <a href="http://www.lri.fr/~filliatr/coqdoc/">coqdoc</a></font>
-</body>
-</html>
\ No newline at end of file
+<LINK type="text/css" rel="stylesheet" href="style.css">
+</HEAD>
+<BODY>
+
+<H1 align="center">The Compcert certified compiler back-end</H1>
+<H2 align="center">Commented Coq development</H2>
+<H3 align="center">Version 0.2, 2006-01-07</H3>
+
+<H2>Introduction</H2>
+
+<P>The Compcert back-end is a compiler that generates PowerPC assembly
+code from a low-level intermediate language called Cminor and a
+slightly more expressive intermediate language called Csharpminor.
+The particularity of this compiler is that it is written mostly within
+the specification language of the Coq proof assistant, and its
+correctness --- the fact that the generated assembly code is
+semantically equivalent to its source program --- was entirely proved
+within the Coq proof assistant.</P>
+
+<P>A high-level overview of the Compcert back-end and its proof of
+correctness can be found in the following paper:</P>
+<CITE>Xavier Leroy, <A
+HREF="http://pauillac.inria.fr/~xleroy/publi/compiler-certif.pdf">Formal
+certification of a compiler back-end, or: programming a compiler with
+a proof assistant</A>. Proceedings of the POPL 2006 symposium.</CITE>
+
+<P>This Web site gives a commented listing of the underlying Coq
+specifications and proofs. Proof scripts and the parts of the
+compiler written directly in Caml are omitted. This development is a
+work in progress; some parts may have changed since the overview paper
+above was written.</P>
+
+<P>This document and all Coq source files referenced from it are
+copyright 2005, 2006 Institut National de Recherche en Informatique et
+en Automatique (INRIA) and distributed under the terms of the <A
+HREF="http://www.gnu.org/licenses/gpl.html">GNU General Public
+License</A> version 2.</P>
+
+<H2>Table of contents</H2>
+
+<H3>General-purpose libraries, data structures and algorithms</H3>
+
+<UL>
+<LI> <A HREF="html/Coqlib.html">Coqlib</A>: addendum to the Coq standard library.
+ (Coq source file with proofs:
+ <A HREF="Coqlib.v"><code>Coqlib.v</code></a>.)
+<LI> <A HREF="html/Maps.html">Maps</A>: finite maps.
+ (Coq source file with proofs:
+ <A HREF="Maps.v"><code>Maps.v</code></a>.)
+<LI> <A HREF="html/Integers.html">Integers</A>: machine integers.
+ (Coq source file with proofs:
+ <A HREF="Integers.v"><code>Integers.v</code></a>.)
+<LI> <A HREF="html/Floats.html">Floats</A>: machine floating-point numbers.
+<LI> <A HREF="html/Iteration.html">Iteration</A>: various forms of "while" loops.
+<LI> <A HREF="html/Ordered.html">Ordered</A>: construction of
+ordered types.
+<LI> <A HREF="html/Lattice.html">Lattice</A>: construction of
+semi-lattices.
+<LI> <A HREF="html/Kildall.html">Kildall</A>: resolution of dataflow
+inequations by fixpoint iteration.
+<LI> <A HREF="html/Parmov.html">Parmov</A>: compilation of parallel assignments.
+</UL>
+
+<H3>Definitions and properties used in many parts of the development</H3>
+
+<UL>
+<LI> <A HREF="html/Errors.html">Errors</A>: the Error monad.
+<LI> <A HREF="html/AST.html">AST</A>: identifiers, whole programs and other
+common elements of abstract syntaxes.
+ (Coq source file with proofs: <A HREF="AST.v"><code>AST.v</code></a>.)
+<LI> <A HREF="html/Values.html">Values</A>: run-time values.
+<LI> <A HREF="html/Events.html">Events</A>: observable events and traces.
+<LI> <A HREF="html/Mem.html">Mem</A>: the memory model.
+<LI> <A HREF="html/Globalenvs.html">Globalenvs</A>: global execution environments.
+<LI> <A HREF="html/Smallstep.html">Smallstep</A>: tools for small-step semantics.
+<LI> <A HREF="html/Op.html">Op</A>: operators, addressing modes and their
+semantics.
+</UL>
+
+<H3>Source, intermediate and target languages: syntax and semantics</H3>
+
+<UL>
+<!--
+ <LI> <A HREF="html/Csharpminor.html">Csharpminor</A>: low-level structured language.
+-->
+<LI> <A HREF="html/Cminor.html">Cminor</A>: low-level structured
+language, with explicit stack allocation of certain local variables.
+<LI> <A HREF="html/CminorSel.html">CminorSel</A>: like Cminor,
+with machine-specific operators and addressing modes.
+<LI> <A HREF="html/RTL.html">RTL</A>: register transfer language (3-address
+code, control-flow graph, infinitely many pseudo-registers). <BR>
+See also: <A HREF="html/Registers.html">Registers</A> (representation of
+pseudo-registers).
+<LI> <A HREF="html/LTL.html">LTL</A>: location transfer language (3-address
+code, control-flow graph, finitely many physical registers, infinitely
+many stack slots). <BR>
+See also: <A HREF="html/Locations.html">Locations</A> (representation of
+locations).
+<LI> <A HREF="html/LTL.html">LTLin</A>: like LTL, but the CFG is
+replaced by a linear list of instructions with explicit branches and labels.
+<LI> <A HREF="html/Linear.html">Linear</A>: like LTLin, with explicit
+spilling, reloading and enforcement of calling conventions.
+<LI> <A HREF="html/Mach.html">Mach</A>: like Linear, with a more concrete
+view of the activation record. <BR>
+See also: <A HREF="html/Machabstr.html">Machabstr</A> abstract semantics for Mach. <BR>
+See also: <A HREF="html/Machconcr.html">Machconcr</A> concrete semantics for Mach.
+<LI> <A HREF="html/PPC.html">PPC</A>: abstract syntax for PowerPC assembly
+code.
+</UL>
+
+<H3>Compiler passes</H3>
+
+<TABLE cellpadding="5%">
+<TR valign="top">
+ <TH>Pass</TH>
+ <TH>Source & target</TH>
+ <TH>Compiler code</TH>
+ <TH>Correctness proof</TH>
+</TR>
+
+<!--
+<TR valign="top">
+ <TD>Stack allocation of local variables<br>whose address is taken</TD>
+ <TD>Csharpminor to Cminor</TD>
+ <TD><A HREF="html/Cminorgen.html">Cminorgen</A></TD>
+ <TD><A HREF="html/Cminorgenproof.html">Cminorgenproof</A></TD>
+</TR>
+-->
+
+<TR valign="top">
+ <TD>Recognition of operators<br>and addressing modes</TD>
+ <TD>Cminor to CminorSel</TD>
+ <TD><A HREF="html/Selection.html">Selection</A></TD>
+ <TD><A HREF="html/Selectionproof.html">Selectionproof</A></TD>
+</TR>
+
+<TR valign="top">
+ <TD>Construction of the CFG, <br>3-address code generation</TD>
+ <TD>Cminor to RTL</TD>
+ <TD><A HREF="html/RTLgen.html">RTLgen</A></TD>
+ <TD><A HREF="html/RTLgenspec.html">RTLgenspec</A><BR>
+ <A HREF="html/RTLgenproof.html">RTLgenproof</A></TD>
+</TR>
+
+<TR valign="top">
+ <TD>Constant propagation</TD>
+ <TD>RTL to RTL</TD>
+ <TD><A HREF="html/Constprop.html">Constprop</A></TD>
+ <TD><A HREF="html/Constpropproof.html">Constpropproof</A></TD>
+</TR>
+
+<TR valign="top">
+ <TD>Common subexpression elimination</TD>
+ <TD>RTL to RTL</TD>
+ <TD><A HREF="html/CSE.html">CSE</A></TD>
+ <TD><A HREF="html/CSEproof.html">CSEproof</A></TD>
+</TR>
+
+<TR valign="top">
+ <TD>Register allocation by coloring<br>of an interference graph</TD>
+ <TD>RTL to LTL</TD>
+ <TD><A HREF="html/InterfGraph.html">InterfGraph</A><BR>
+ <A HREF="html/Coloring.html">Coloring</A><BR>
+ <A HREF="html/Allocation.html">Allocation</A></TD>
+ <TD><BR>
+ <A HREF="html/Coloringproof.html">Coloringproof</A><BR>
+ <A HREF="html/Allocproof.html">Allocproof</A></TD>
+</TR>
+
+<TR valign="top">
+ <TD>Branch tunneling</TD>
+ <TD>LTL to LTL</TD>
+ <TD><A HREF="html/Tunneling.html">Tunneling</A></TD>
+ <TD><A HREF="html/Tunnelingproof.html">Tunnelingproof</A></TD>
+</TR>
+
+<TR valign="top">
+ <TD>Linearization of the CFG</TD>
+ <TD>LTL to LTLin</TD>
+ <TD><A HREF="html/Linearize.html">Linearize</A></TD>
+ <TD><A HREF="html/Linearizeproof.html">Linearizeproof</A></TD>
+</TR>
+
+<TR valign="top">
+ <TD>Spilling, reloading, calling conventions</TD>
+ <TD>LTLin to Linear</TD>
+ <TD><A HREF="html/Conventions.html">Conventions</A><BR>
+ <A HREF="html/Reload.html">Reload</A></TD>
+ <TD><A HREF="html/Parallelmove.html">Parallelmove</A><BR>
+ <A HREF="html/Reloadproof.html">Reloadproof</A></TD>
+</TR>
+
+<TR valign="top">
+ <TD>Laying out the activation records</TD>
+ <TD>Linear to Mach</TD>
+ <TD><A HREF="html/Bounds.html">Bounds</A><BR>
+ <A HREF="html/Stacking.html">Stacking</A></TD>
+ <TD><A HREF="html/Stackingproof.html">Stackingproof</A></TD>
+</TR>
+
+<TR valign="top">
+ <TD>Storing the activation records in memory</TD>
+ <TD>Mach to Mach</TD>
+ <TD>(none)
+ <TD><A HREF="html/PPCgenretaddr.html">PPCgenretaddr</A><BR>
+ <A HREF="html/Machabstr2mach.html">Machabstr2mach</A></TD>
+
+<TR valign="top">
+ <TD>Emission of PowerPC assembly</TD>
+ <TD>Mach to PPC</TD>
+ <TD><A HREF="html/PPCgen.html">PPCgen</A></TD>
+ <TD><A HREF="html/PPCgenproof1.html">PPCgenproof1</A><BR>
+ <A HREF="html/PPCgenproof.html">PPCgenproof</A></TD>
+</TR>
+</TABLE>
+
+<H3>Type systems</H3>
+
+Trivial type systems are used to statically capture well-formedness
+conditions on the intermediate languages.
+<UL>
+<LI> <A HREF="html/RTLtyping.html">RTLtyping</A>: typing for RTL + type
+reconstruction.
+<LI> <A HREF="html/LTLtyping.html">LTLtyping</A>: typing for LTL.
+<LI> <A HREF="html/LTLintyping.html">LTLintyping</A>: typing for LTLin.
+<LI> <A HREF="html/Lineartyping.html">Lineartyping</A>: typing for Linear.
+<LI> <A HREF="html/Machtyping.html">Machtyping</A>: typing for Mach.
+</UL>
+Proofs that compiler passes are type-preserving:
+<UL>
+<LI> <A HREF="html/Alloctyping.html">Alloctyping</A> (register allocation).
+<LI> <A HREF="html/Tunnelingtyping.html">Tunnelingtyping</A> (branch tunneling).
+<LI> <A HREF="html/Linearizetyping.html">Linearizetyping</A> (code linearization).
+<LI> <A HREF="html/Reloadtyping.html">Reloadtyping</A> (spilling and reloading).
+<LI> <A HREF="html/Stackingtyping.html">Stackingtyping</A> (layout of activation records).
+</UL>
+
+<H3>All together</H3>
+
+<UL>
+<LI> <A HREF="html/Main.html">Main</A>: composing the passes together; the
+final semantic preservation theorems.
+</UL>
+
+<HR>
+<ADDRESS>Xavier.Leroy@inria.fr</ADDRESS>
+<HR>
+
+</BODY>
+</HTML>
diff --git a/doc/removeproofs b/doc/removeproofs
index 0ebe3a8b0bc1b4ec812691118a362075f0f65f3e..82809ba685a6411ce199cd54c8cb8cd06d354495 100755
--- a/doc/removeproofs
+++ b/doc/removeproofs
@@ -2,7 +2,7 @@
for i in $*; do
mv $i $i.bak
- sed -e '/<code class="keyword">Proof<\/code>\./,/<code class="keyword">Qed<\/code>\./d' $i.bak > $i
+ sed -e '/<code class="keyword">Proof<\/code> *\./,/<code class="keyword">\(Qed\|Defined\)<\/code> *\./d' $i.bak > $i
rm $i.bak
done
diff --git a/doc/style.css b/doc/style.css
index 9c1eb491779e4a1c213b3f0241f38dc95c025e00..dced2fffa9717ac9af3a0984fb1539a6935fbe85 100644
--- a/doc/style.css
+++ b/doc/style.css
@@ -26,7 +26,9 @@ tr { background-color : White }
# .doc { background-color :#66ff66 }
.doc { margin-left: -5%; }
.docright { margin-left: 40%; }
-h1 { margin-left: -10%; text-align: right; }
+div.doc code { color : #008000; font-weight: bold }
+h1.libtitle { text-align: center; }
+h1 { margin-left: -5%; }
h2 { margin-left: -5%; }
h3,h4,h5,h6 { margin-left: -3%; }
hr { margin-left: -10%; margin-right:-10%; }
diff --git a/extraction/.depend b/extraction/.depend
index 53f846878839681106272cdfc1f2926abae77a68..956c4d338bcb284727e5e5a2de484d1aa7c6974e 100644
--- a/extraction/.depend
+++ b/extraction/.depend
@@ -8,20 +8,20 @@
../caml/CMlexer.cmi
../caml/CMlexer.cmx: ../caml/Camlcoq.cmx ../caml/CMparser.cmx \
../caml/CMlexer.cmi
-../caml/CMparser.cmo: Op.cmi Integers.cmi Datatypes.cmi Cminor.cmi \
- Cmconstr.cmi ../caml/Camlcoq.cmo CList.cmi BinPos.cmi BinInt.cmi AST.cmi \
+../caml/CMparser.cmo: Integers.cmi Datatypes.cmi Cminor.cmi \
+ ../caml/Camlcoq.cmo CList.cmi BinPos.cmi BinInt.cmi AST.cmi \
../caml/CMparser.cmi
-../caml/CMparser.cmx: Op.cmx Integers.cmx Datatypes.cmx Cminor.cmx \
- Cmconstr.cmx ../caml/Camlcoq.cmx CList.cmx BinPos.cmx BinInt.cmx AST.cmx \
+../caml/CMparser.cmx: Integers.cmx Datatypes.cmx Cminor.cmx \
+ ../caml/Camlcoq.cmx CList.cmx BinPos.cmx BinInt.cmx AST.cmx \
../caml/CMparser.cmi
../caml/CMtypecheck.cmo: Op.cmi Integers.cmi Datatypes.cmi Cminor.cmi \
../caml/Camlcoq.cmo CList.cmi AST.cmi ../caml/CMtypecheck.cmi
../caml/CMtypecheck.cmx: Op.cmx Integers.cmx Datatypes.cmx Cminor.cmx \
../caml/Camlcoq.cmx CList.cmx AST.cmx ../caml/CMtypecheck.cmi
-../caml/Camlcoq.cmo: Integers.cmi Datatypes.cmi CList.cmi BinPos.cmi \
- BinInt.cmi
-../caml/Camlcoq.cmx: Integers.cmx Datatypes.cmx CList.cmx BinPos.cmx \
- BinInt.cmx
+../caml/Camlcoq.cmo: Integers.cmi Datatypes.cmi CString.cmi CList.cmi \
+ BinPos.cmi BinInt.cmi Ascii.cmi
+../caml/Camlcoq.cmx: Integers.cmx Datatypes.cmx CString.cmx CList.cmx \
+ BinPos.cmx BinInt.cmx Ascii.cmx
../caml/Cil2Csyntax.cmo: Datatypes.cmi Csyntax.cmi ../caml/Camlcoq.cmo \
CList.cmi AST.cmi
../caml/Cil2Csyntax.cmx: Datatypes.cmx Csyntax.cmx ../caml/Camlcoq.cmx \
@@ -35,15 +35,11 @@
../caml/Floataux.cmo: Integers.cmi ../caml/Camlcoq.cmo
../caml/Floataux.cmx: Integers.cmx ../caml/Camlcoq.cmx
../caml/Main2.cmo: ../caml/PrintPPC.cmi ../caml/PrintCsyntax.cmo Main.cmi \
- Datatypes.cmi Csyntax.cmi ../caml/Cil2Csyntax.cmo ../caml/CMtypecheck.cmi \
+ Errors.cmi Csyntax.cmi ../caml/Cil2Csyntax.cmo ../caml/CMtypecheck.cmi \
../caml/CMparser.cmi ../caml/CMlexer.cmi
../caml/Main2.cmx: ../caml/PrintPPC.cmx ../caml/PrintCsyntax.cmx Main.cmx \
- Datatypes.cmx Csyntax.cmx ../caml/Cil2Csyntax.cmx ../caml/CMtypecheck.cmx \
+ Errors.cmx Csyntax.cmx ../caml/Cil2Csyntax.cmx ../caml/CMtypecheck.cmx \
../caml/CMparser.cmx ../caml/CMlexer.cmx
-../caml/PrintCshm.cmo: Integers.cmi Datatypes.cmi Csharpminor.cmi \
- ../caml/Camlcoq.cmo CList.cmi AST.cmi
-../caml/PrintCshm.cmx: Integers.cmx Datatypes.cmx Csharpminor.cmx \
- ../caml/Camlcoq.cmx CList.cmx AST.cmx
../caml/PrintCsyntax.cmo: Datatypes.cmi Csyntax.cmi ../caml/Camlcoq.cmo \
CList.cmi AST.cmi
../caml/PrintCsyntax.cmx: Datatypes.cmx Csyntax.cmx ../caml/Camlcoq.cmx \
@@ -52,32 +48,40 @@
AST.cmi ../caml/PrintPPC.cmi
../caml/PrintPPC.cmx: PPC.cmx Datatypes.cmx ../caml/Camlcoq.cmx CList.cmx \
AST.cmx ../caml/PrintPPC.cmi
-../caml/RTLgenaux.cmo: Cminor.cmi
-../caml/RTLgenaux.cmx: Cminor.cmx
+../caml/RTLgenaux.cmo: Switch.cmi Integers.cmi Datatypes.cmi CminorSel.cmi \
+ CList.cmi
+../caml/RTLgenaux.cmx: Switch.cmx Integers.cmx Datatypes.cmx CminorSel.cmx \
+ CList.cmx
../caml/RTLtypingaux.cmo: Registers.cmi RTL.cmi Op.cmi Maps.cmi Datatypes.cmi \
../caml/Camlcoq.cmo CList.cmi AST.cmi
../caml/RTLtypingaux.cmx: Registers.cmx RTL.cmx Op.cmx Maps.cmx Datatypes.cmx \
../caml/Camlcoq.cmx CList.cmx AST.cmx
-AST.cmi: Specif.cmi Integers.cmi Floats.cmi Datatypes.cmi Coqlib.cmi \
- CList.cmi BinPos.cmi BinInt.cmi
-Allocation.cmi: Specif.cmi Registers.cmi RTLtyping.cmi RTL.cmi \
- Parallelmove.cmi Op.cmi Maps.cmi Locations.cmi LTL.cmi Datatypes.cmi \
- Conventions.cmi Coloring.cmi CList.cmi BinPos.cmi AST.cmi
+AST.cmi: Specif.cmi Integers.cmi Floats.cmi Errors.cmi Datatypes.cmi \
+ Coqlib.cmi CString.cmi CList.cmi BinPos.cmi BinInt.cmi Ascii.cmi
+Allocation.cmi: Specif.cmi Registers.cmi RTLtyping.cmi RTL.cmi Op.cmi \
+ Maps.cmi Locations.cmi LTL.cmi Errors.cmi Datatypes.cmi Coloring.cmi \
+ CString.cmi CList.cmi BinPos.cmi Ascii.cmi AST.cmi
+Ascii.cmi: Specif.cmi Peano.cmi Datatypes.cmi Bool.cmi BinPos.cmi
BinInt.cmi: Datatypes.cmi BinPos.cmi BinNat.cmi
BinNat.cmi: Specif.cmi Datatypes.cmi BinPos.cmi
BinPos.cmi: Peano.cmi Datatypes.cmi
Bool.cmi: Specif.cmi Datatypes.cmi
+Bounds.cmi: Zmax.cmi Locations.cmi Linear.cmi Conventions.cmi CList.cmi \
+ BinPos.cmi BinInt.cmi AST.cmi
CInt.cmi: Zmax.cmi ZArith_dec.cmi Specif.cmi BinPos.cmi BinInt.cmi
CList.cmi: Specif.cmi Datatypes.cmi
CSE.cmi: Specif.cmi Registers.cmi RTL.cmi Op.cmi Maps.cmi Integers.cmi \
Floats.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi AST.cmi
-Cmconstr.cmi: Specif.cmi Op.cmi Integers.cmi Datatypes.cmi Compare_dec.cmi \
- Cminor.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi
-Cminor.cmi: Values.cmi Op.cmi Maps.cmi Integers.cmi Globalenvs.cmi \
- Datatypes.cmi CList.cmi BinInt.cmi AST.cmi
-Cminorgen.cmi: Zmax.cmi Specif.cmi OrderedType.cmi Ordered.cmi Op.cmi Mem.cmi \
- Maps.cmi Integers.cmi Datatypes.cmi Csharpminor.cmi Coqlib.cmi Cminor.cmi \
- Cmconstr.cmi CList.cmi CInt.cmi BinPos.cmi BinInt.cmi AST.cmi
+CString.cmi: Specif.cmi Datatypes.cmi Ascii.cmi
+Cminor.cmi: Values.cmi Specif.cmi Mem.cmi Maps.cmi Integers.cmi \
+ Globalenvs.cmi Floats.cmi Datatypes.cmi CList.cmi BinPos.cmi BinInt.cmi \
+ AST.cmi
+CminorSel.cmi: Op.cmi Integers.cmi Globalenvs.cmi Datatypes.cmi CList.cmi \
+ BinInt.cmi AST.cmi
+Cminorgen.cmi: Zmax.cmi Specif.cmi OrderedType.cmi Ordered.cmi Mem.cmi \
+ Maps.cmi Integers.cmi Errors.cmi Datatypes.cmi Csharpminor.cmi Coqlib.cmi \
+ Cminor.cmi CString.cmi CList.cmi CInt.cmi BinPos.cmi BinInt.cmi Ascii.cmi \
+ AST.cmi
Coloring.cmi: Specif.cmi Registers.cmi RTLtyping.cmi RTL.cmi Op.cmi Maps.cmi \
Locations.cmi InterfGraph.cmi Datatypes.cmi Coqlib.cmi Conventions.cmi \
CList.cmi BinInt.cmi AST.cmi
@@ -88,15 +92,19 @@ Conventions.cmi: Locations.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi \
BinInt.cmi AST.cmi
Coqlib.cmi: Zdiv.cmi ZArith_dec.cmi Wf.cmi Specif.cmi Datatypes.cmi CList.cmi \
BinPos.cmi BinInt.cmi
-Csharpminor.cmi: Zmax.cmi Values.cmi Specif.cmi Mem.cmi Maps.cmi Integers.cmi \
- Globalenvs.cmi Floats.cmi Datatypes.cmi CList.cmi BinPos.cmi BinInt.cmi \
+Csharpminor.cmi: Zmax.cmi Values.cmi Mem.cmi Maps.cmi Integers.cmi \
+ Globalenvs.cmi Floats.cmi Datatypes.cmi Cminor.cmi CList.cmi BinInt.cmi \
AST.cmi
-Cshmgen.cmi: Peano.cmi Integers.cmi Floats.cmi Datatypes.cmi Csyntax.cmi \
- Csharpminor.cmi CList.cmi AST.cmi
-Csyntax.cmi: Zmax.cmi Specif.cmi Integers.cmi Floats.cmi Datatypes.cmi \
- Coqlib.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi
+Cshmgen.cmi: Peano.cmi Integers.cmi Floats.cmi Errors.cmi Datatypes.cmi \
+ Csyntax.cmi Csharpminor.cmi Cminor.cmi CString.cmi CList.cmi Ascii.cmi \
+ AST.cmi
+Csyntax.cmi: Zmax.cmi Specif.cmi Integers.cmi Floats.cmi Errors.cmi \
+ Datatypes.cmi Coqlib.cmi CString.cmi CList.cmi BinPos.cmi BinInt.cmi \
+ Ascii.cmi AST.cmi
Ctyping.cmi: Specif.cmi Maps.cmi Datatypes.cmi Csyntax.cmi Coqlib.cmi \
CList.cmi AST.cmi
+EqNat.cmi: Specif.cmi Datatypes.cmi
+Errors.cmi: Datatypes.cmi CString.cmi CList.cmi BinPos.cmi
FSetAVL.cmi: Wf.cmi Specif.cmi Peano.cmi OrderedType.cmi Datatypes.cmi \
CList.cmi CInt.cmi BinPos.cmi BinInt.cmi
FSetFacts.cmi: Specif.cmi Setoid.cmi FSetInterface.cmi Datatypes.cmi
@@ -110,34 +118,36 @@ Integers.cmi: Zpower.cmi Zdiv.cmi Specif.cmi Datatypes.cmi Coqlib.cmi \
InterfGraph.cmi: Specif.cmi Registers.cmi OrderedType.cmi Locations.cmi \
Datatypes.cmi Coqlib.cmi CList.cmi CInt.cmi BinPos.cmi BinInt.cmi
Iteration.cmi: Wf.cmi Specif.cmi Datatypes.cmi Coqlib.cmi BinPos.cmi
-Kildall.cmi: Specif.cmi Setoid.cmi OrderedType.cmi Maps.cmi Lattice.cmi \
- Iteration.cmi Datatypes.cmi Coqlib.cmi CList.cmi CInt.cmi BinPos.cmi \
- BinInt.cmi
-LTL.cmi: Values.cmi Specif.cmi Op.cmi Maps.cmi Locations.cmi Integers.cmi \
- Globalenvs.cmi Datatypes.cmi Conventions.cmi CList.cmi BinPos.cmi \
- BinInt.cmi AST.cmi
+Kildall.cmi: Specif.cmi Setoid.cmi OrderedType.cmi Ordered.cmi Maps.cmi \
+ Lattice.cmi Iteration.cmi Datatypes.cmi Coqlib.cmi CList.cmi CInt.cmi \
+ BinPos.cmi BinInt.cmi
+LTL.cmi: Values.cmi Specif.cmi Op.cmi Mem.cmi Maps.cmi Locations.cmi \
+ Integers.cmi Globalenvs.cmi Datatypes.cmi Conventions.cmi CList.cmi \
+ BinPos.cmi BinInt.cmi AST.cmi
+LTLin.cmi: Values.cmi Specif.cmi Op.cmi Mem.cmi Locations.cmi Integers.cmi \
+ Globalenvs.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi BinInt.cmi \
+ AST.cmi
Lattice.cmi: Specif.cmi Maps.cmi FSetInterface.cmi Datatypes.cmi Bool.cmi \
BinPos.cmi
-Linear.cmi: Values.cmi Specif.cmi Op.cmi Locations.cmi Integers.cmi \
+Linear.cmi: Values.cmi Specif.cmi Op.cmi Mem.cmi Locations.cmi Integers.cmi \
Globalenvs.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi BinInt.cmi \
AST.cmi
-Linearize.cmi: Specif.cmi Op.cmi Maps.cmi Linear.cmi Lattice.cmi LTL.cmi \
+Linearize.cmi: Specif.cmi Op.cmi Maps.cmi Lattice.cmi LTLin.cmi LTL.cmi \
Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi AST.cmi
-Lineartyping.cmi: Zmax.cmi Locations.cmi Linear.cmi Datatypes.cmi \
- Conventions.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi
Locations.cmi: Values.cmi Specif.cmi Datatypes.cmi Coqlib.cmi BinPos.cmi \
BinInt.cmi AST.cmi
-Mach.cmi: Zmax.cmi Zdiv.cmi Values.cmi Specif.cmi Op.cmi Mem.cmi \
- Locations.cmi Integers.cmi Globalenvs.cmi Datatypes.cmi Coqlib.cmi \
- CList.cmi BinPos.cmi BinInt.cmi AST.cmi
-Main.cmi: Tunneling.cmi Stacking.cmi RTLgen.cmi PPCgen.cmi PPC.cmi \
- Linearize.cmi Datatypes.cmi Ctyping.cmi Csyntax.cmi Cshmgen.cmi \
- Constprop.cmi Cminorgen.cmi Cminor.cmi CSE.cmi Allocation.cmi AST.cmi
+Mach.cmi: Zmax.cmi Zdiv.cmi Values.cmi Specif.cmi Op.cmi Locations.cmi \
+ Integers.cmi Globalenvs.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi \
+ BinInt.cmi AST.cmi
+Main.cmi: Tunneling.cmi Stacking.cmi Selection.cmi Reload.cmi RTLgen.cmi \
+ RTL.cmi PPCgen.cmi PPC.cmi Linearize.cmi Errors.cmi Datatypes.cmi \
+ Ctyping.cmi Csyntax.cmi Cshmgen.cmi Constprop.cmi Cminorgen.cmi \
+ Cminor.cmi CString.cmi CSE.cmi Ascii.cmi Allocation.cmi AST.cmi
Maps.cmi: Specif.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi BinNat.cmi \
BinInt.cmi
Mem.cmi: Zmax.cmi Values.cmi Specif.cmi Integers.cmi Datatypes.cmi Coqlib.cmi \
CList.cmi BinPos.cmi BinInt.cmi AST.cmi
-Op.cmi: Values.cmi Specif.cmi Integers.cmi Globalenvs.cmi Floats.cmi \
+Op.cmi: Values.cmi Specif.cmi Mem.cmi Integers.cmi Globalenvs.cmi Floats.cmi \
Datatypes.cmi CList.cmi Bool.cmi BinPos.cmi BinInt.cmi AST.cmi
Ordered.cmi: Specif.cmi OrderedType.cmi Maps.cmi Datatypes.cmi Coqlib.cmi \
BinPos.cmi
@@ -145,24 +155,32 @@ OrderedType.cmi: Specif.cmi Datatypes.cmi
PPC.cmi: Values.cmi Specif.cmi Mem.cmi Integers.cmi Globalenvs.cmi Floats.cmi \
Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi
PPCgen.cmi: Specif.cmi PPC.cmi Op.cmi Mach.cmi Locations.cmi Integers.cmi \
- Datatypes.cmi Coqlib.cmi CList.cmi Bool.cmi BinPos.cmi BinInt.cmi AST.cmi
+ Errors.cmi Datatypes.cmi Coqlib.cmi CString.cmi CList.cmi Bool.cmi \
+ BinPos.cmi BinInt.cmi Ascii.cmi AST.cmi
Parallelmove.cmi: Parmov.cmi Locations.cmi Datatypes.cmi CList.cmi AST.cmi
Parmov.cmi: Specif.cmi Peano.cmi Datatypes.cmi CList.cmi
Peano.cmi: Datatypes.cmi
-RTL.cmi: Values.cmi Registers.cmi Op.cmi Maps.cmi Integers.cmi Globalenvs.cmi \
- Datatypes.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi
-RTLgen.cmi: Specif.cmi Registers.cmi RTL.cmi Op.cmi Maps.cmi Integers.cmi \
- Datatypes.cmi Coqlib.cmi Cminor.cmi CList.cmi BinPos.cmi AST.cmi
-RTLtyping.cmi: Specif.cmi Registers.cmi RTL.cmi Op.cmi Maps.cmi Datatypes.cmi \
- Coqlib.cmi CList.cmi AST.cmi
+RTL.cmi: Values.cmi Registers.cmi Op.cmi Mem.cmi Maps.cmi Integers.cmi \
+ Globalenvs.cmi Datatypes.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi
+RTLgen.cmi: Switch.cmi Specif.cmi Registers.cmi RTL.cmi Op.cmi Maps.cmi \
+ Integers.cmi Errors.cmi Datatypes.cmi Coqlib.cmi CminorSel.cmi \
+ CString.cmi CList.cmi BinPos.cmi Ascii.cmi AST.cmi
+RTLtyping.cmi: Specif.cmi Registers.cmi RTL.cmi Op.cmi Maps.cmi Errors.cmi \
+ Datatypes.cmi Coqlib.cmi Conventions.cmi CString.cmi CList.cmi BinPos.cmi \
+ BinInt.cmi Ascii.cmi AST.cmi
Registers.cmi: Specif.cmi OrderedType.cmi Ordered.cmi Maps.cmi Datatypes.cmi \
Coqlib.cmi CList.cmi CInt.cmi BinPos.cmi BinInt.cmi AST.cmi
+Reload.cmi: Specif.cmi Parallelmove.cmi Op.cmi Locations.cmi Linear.cmi \
+ LTLin.cmi Datatypes.cmi Conventions.cmi CList.cmi AST.cmi
+Selection.cmi: Specif.cmi Op.cmi Integers.cmi Datatypes.cmi Compare_dec.cmi \
+ CminorSel.cmi Cminor.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi
Setoid.cmi: Datatypes.cmi
Specif.cmi: Datatypes.cmi
-Stacking.cmi: Specif.cmi Op.cmi Mach.cmi Locations.cmi Lineartyping.cmi \
- Linear.cmi Integers.cmi Datatypes.cmi Coqlib.cmi Conventions.cmi \
- CList.cmi BinPos.cmi BinInt.cmi AST.cmi
+Stacking.cmi: Specif.cmi Op.cmi Mach.cmi Locations.cmi Linear.cmi \
+ Integers.cmi Errors.cmi Datatypes.cmi Coqlib.cmi Conventions.cmi \
+ CString.cmi CList.cmi Bounds.cmi BinPos.cmi BinInt.cmi Ascii.cmi AST.cmi
Sumbool.cmi: Specif.cmi Datatypes.cmi
+Switch.cmi: Integers.cmi EqNat.cmi Datatypes.cmi CList.cmi
Tunneling.cmi: Maps.cmi LTL.cmi Datatypes.cmi AST.cmi
Values.cmi: Specif.cmi Integers.cmi Floats.cmi Datatypes.cmi Coqlib.cmi \
BinPos.cmi BinInt.cmi AST.cmi
@@ -175,18 +193,20 @@ Zeven.cmi: Specif.cmi Datatypes.cmi BinPos.cmi BinInt.cmi
Zmax.cmi: Datatypes.cmi BinInt.cmi
Zmisc.cmi: Datatypes.cmi BinPos.cmi BinInt.cmi
Zpower.cmi: Zmisc.cmi Datatypes.cmi BinPos.cmi BinInt.cmi
-AST.cmo: Specif.cmi Integers.cmi Floats.cmi Datatypes.cmi Coqlib.cmi \
- CList.cmi BinPos.cmi BinInt.cmi AST.cmi
-AST.cmx: Specif.cmx Integers.cmx Floats.cmx Datatypes.cmx Coqlib.cmx \
- CList.cmx BinPos.cmx BinInt.cmx AST.cmi
-Allocation.cmo: Specif.cmi Registers.cmi RTLtyping.cmi RTL.cmi \
- Parallelmove.cmi Op.cmi Maps.cmi Locations.cmi Lattice.cmi LTL.cmi \
- Kildall.cmi Datatypes.cmi Conventions.cmi Coloring.cmi CList.cmi \
- BinPos.cmi AST.cmi Allocation.cmi
-Allocation.cmx: Specif.cmx Registers.cmx RTLtyping.cmx RTL.cmx \
- Parallelmove.cmx Op.cmx Maps.cmx Locations.cmx Lattice.cmx LTL.cmx \
- Kildall.cmx Datatypes.cmx Conventions.cmx Coloring.cmx CList.cmx \
- BinPos.cmx AST.cmx Allocation.cmi
+AST.cmo: Specif.cmi Integers.cmi Floats.cmi Errors.cmi Datatypes.cmi \
+ Coqlib.cmi CString.cmi CList.cmi BinPos.cmi BinInt.cmi Ascii.cmi AST.cmi
+AST.cmx: Specif.cmx Integers.cmx Floats.cmx Errors.cmx Datatypes.cmx \
+ Coqlib.cmx CString.cmx CList.cmx BinPos.cmx BinInt.cmx Ascii.cmx AST.cmi
+Allocation.cmo: Specif.cmi Registers.cmi RTLtyping.cmi RTL.cmi Op.cmi \
+ Maps.cmi Locations.cmi Lattice.cmi LTL.cmi Kildall.cmi Errors.cmi \
+ Datatypes.cmi Coloring.cmi CString.cmi CList.cmi BinPos.cmi Ascii.cmi \
+ AST.cmi Allocation.cmi
+Allocation.cmx: Specif.cmx Registers.cmx RTLtyping.cmx RTL.cmx Op.cmx \
+ Maps.cmx Locations.cmx Lattice.cmx LTL.cmx Kildall.cmx Errors.cmx \
+ Datatypes.cmx Coloring.cmx CString.cmx CList.cmx BinPos.cmx Ascii.cmx \
+ AST.cmx Allocation.cmi
+Ascii.cmo: Specif.cmi Peano.cmi Datatypes.cmi Bool.cmi BinPos.cmi Ascii.cmi
+Ascii.cmx: Specif.cmx Peano.cmx Datatypes.cmx Bool.cmx BinPos.cmx Ascii.cmi
BinInt.cmo: Datatypes.cmi BinPos.cmi BinNat.cmi BinInt.cmi
BinInt.cmx: Datatypes.cmx BinPos.cmx BinNat.cmx BinInt.cmi
BinNat.cmo: Specif.cmi Datatypes.cmi BinPos.cmi BinNat.cmi
@@ -195,6 +215,10 @@ BinPos.cmo: Peano.cmi Datatypes.cmi BinPos.cmi
BinPos.cmx: Peano.cmx Datatypes.cmx BinPos.cmi
Bool.cmo: Specif.cmi Datatypes.cmi Bool.cmi
Bool.cmx: Specif.cmx Datatypes.cmx Bool.cmi
+Bounds.cmo: Zmax.cmi Locations.cmi Linear.cmi Conventions.cmi CList.cmi \
+ BinPos.cmi BinInt.cmi AST.cmi Bounds.cmi
+Bounds.cmx: Zmax.cmx Locations.cmx Linear.cmx Conventions.cmx CList.cmx \
+ BinPos.cmx BinInt.cmx AST.cmx Bounds.cmi
CInt.cmo: Zmax.cmi ZArith_dec.cmi Specif.cmi BinPos.cmi BinInt.cmi CInt.cmi
CInt.cmx: Zmax.cmx ZArith_dec.cmx Specif.cmx BinPos.cmx BinInt.cmx CInt.cmi
CList.cmo: Specif.cmi Datatypes.cmi CList.cmi
@@ -205,22 +229,26 @@ CSE.cmo: Specif.cmi Registers.cmi RTL.cmi Op.cmi Maps.cmi Kildall.cmi \
CSE.cmx: Specif.cmx Registers.cmx RTL.cmx Op.cmx Maps.cmx Kildall.cmx \
Integers.cmx Floats.cmx Datatypes.cmx Coqlib.cmx CList.cmx BinPos.cmx \
AST.cmx CSE.cmi
-Cmconstr.cmo: Specif.cmi Op.cmi Integers.cmi Datatypes.cmi Compare_dec.cmi \
- Cminor.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi Cmconstr.cmi
-Cmconstr.cmx: Specif.cmx Op.cmx Integers.cmx Datatypes.cmx Compare_dec.cmx \
- Cminor.cmx CList.cmx BinPos.cmx BinInt.cmx AST.cmx Cmconstr.cmi
-Cminor.cmo: Values.cmi Op.cmi Maps.cmi Integers.cmi Globalenvs.cmi \
- Datatypes.cmi CList.cmi BinInt.cmi AST.cmi Cminor.cmi
-Cminor.cmx: Values.cmx Op.cmx Maps.cmx Integers.cmx Globalenvs.cmx \
- Datatypes.cmx CList.cmx BinInt.cmx AST.cmx Cminor.cmi
-Cminorgen.cmo: Zmax.cmi Specif.cmi OrderedType.cmi Ordered.cmi Op.cmi Mem.cmi \
- Maps.cmi Integers.cmi FSetAVL.cmi Datatypes.cmi Csharpminor.cmi \
- Coqlib.cmi Cminor.cmi Cmconstr.cmi CList.cmi BinPos.cmi BinInt.cmi \
- AST.cmi Cminorgen.cmi
-Cminorgen.cmx: Zmax.cmx Specif.cmx OrderedType.cmx Ordered.cmx Op.cmx Mem.cmx \
- Maps.cmx Integers.cmx FSetAVL.cmx Datatypes.cmx Csharpminor.cmx \
- Coqlib.cmx Cminor.cmx Cmconstr.cmx CList.cmx BinPos.cmx BinInt.cmx \
- AST.cmx Cminorgen.cmi
+CString.cmo: Specif.cmi Datatypes.cmi Ascii.cmi CString.cmi
+CString.cmx: Specif.cmx Datatypes.cmx Ascii.cmx CString.cmi
+Cminor.cmo: Values.cmi Specif.cmi Mem.cmi Maps.cmi Integers.cmi \
+ Globalenvs.cmi Floats.cmi Datatypes.cmi CList.cmi BinPos.cmi BinInt.cmi \
+ AST.cmi Cminor.cmi
+Cminor.cmx: Values.cmx Specif.cmx Mem.cmx Maps.cmx Integers.cmx \
+ Globalenvs.cmx Floats.cmx Datatypes.cmx CList.cmx BinPos.cmx BinInt.cmx \
+ AST.cmx Cminor.cmi
+CminorSel.cmo: Op.cmi Integers.cmi Globalenvs.cmi Datatypes.cmi CList.cmi \
+ BinInt.cmi AST.cmi CminorSel.cmi
+CminorSel.cmx: Op.cmx Integers.cmx Globalenvs.cmx Datatypes.cmx CList.cmx \
+ BinInt.cmx AST.cmx CminorSel.cmi
+Cminorgen.cmo: Zmax.cmi Specif.cmi OrderedType.cmi Ordered.cmi Mem.cmi \
+ Maps.cmi Integers.cmi FSetAVL.cmi Errors.cmi Datatypes.cmi \
+ Csharpminor.cmi Coqlib.cmi Cminor.cmi CString.cmi CList.cmi BinPos.cmi \
+ BinInt.cmi Ascii.cmi AST.cmi Cminorgen.cmi
+Cminorgen.cmx: Zmax.cmx Specif.cmx OrderedType.cmx Ordered.cmx Mem.cmx \
+ Maps.cmx Integers.cmx FSetAVL.cmx Errors.cmx Datatypes.cmx \
+ Csharpminor.cmx Coqlib.cmx Cminor.cmx CString.cmx CList.cmx BinPos.cmx \
+ BinInt.cmx Ascii.cmx AST.cmx Cminorgen.cmi
Coloring.cmo: Specif.cmi Registers.cmi RTLtyping.cmi RTL.cmi Op.cmi Maps.cmi \
Locations.cmi InterfGraph.cmi Datatypes.cmi Coqlib.cmi Conventions.cmi \
../caml/Coloringaux.cmi CList.cmi BinInt.cmi AST.cmi Coloring.cmi
@@ -243,26 +271,34 @@ Coqlib.cmo: Zdiv.cmi ZArith_dec.cmi Wf.cmi Specif.cmi Datatypes.cmi CList.cmi \
BinPos.cmi BinInt.cmi Coqlib.cmi
Coqlib.cmx: Zdiv.cmx ZArith_dec.cmx Wf.cmx Specif.cmx Datatypes.cmx CList.cmx \
BinPos.cmx BinInt.cmx Coqlib.cmi
-Csharpminor.cmo: Zmax.cmi Values.cmi Specif.cmi Mem.cmi Maps.cmi Integers.cmi \
- Globalenvs.cmi Floats.cmi Datatypes.cmi CList.cmi BinPos.cmi BinInt.cmi \
+Csharpminor.cmo: Zmax.cmi Values.cmi Mem.cmi Maps.cmi Integers.cmi \
+ Globalenvs.cmi Floats.cmi Datatypes.cmi Cminor.cmi CList.cmi BinInt.cmi \
AST.cmi Csharpminor.cmi
-Csharpminor.cmx: Zmax.cmx Values.cmx Specif.cmx Mem.cmx Maps.cmx Integers.cmx \
- Globalenvs.cmx Floats.cmx Datatypes.cmx CList.cmx BinPos.cmx BinInt.cmx \
+Csharpminor.cmx: Zmax.cmx Values.cmx Mem.cmx Maps.cmx Integers.cmx \
+ Globalenvs.cmx Floats.cmx Datatypes.cmx Cminor.cmx CList.cmx BinInt.cmx \
AST.cmx Csharpminor.cmi
-Cshmgen.cmo: Peano.cmi Integers.cmi Floats.cmi Datatypes.cmi Csyntax.cmi \
- Csharpminor.cmi CList.cmi AST.cmi Cshmgen.cmi
-Cshmgen.cmx: Peano.cmx Integers.cmx Floats.cmx Datatypes.cmx Csyntax.cmx \
- Csharpminor.cmx CList.cmx AST.cmx Cshmgen.cmi
-Csyntax.cmo: Zmax.cmi Specif.cmi Integers.cmi Floats.cmi Datatypes.cmi \
- Coqlib.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi Csyntax.cmi
-Csyntax.cmx: Zmax.cmx Specif.cmx Integers.cmx Floats.cmx Datatypes.cmx \
- Coqlib.cmx CList.cmx BinPos.cmx BinInt.cmx AST.cmx Csyntax.cmi
+Cshmgen.cmo: Peano.cmi Integers.cmi Floats.cmi Errors.cmi Datatypes.cmi \
+ Csyntax.cmi Csharpminor.cmi Cminor.cmi CString.cmi CList.cmi Ascii.cmi \
+ AST.cmi Cshmgen.cmi
+Cshmgen.cmx: Peano.cmx Integers.cmx Floats.cmx Errors.cmx Datatypes.cmx \
+ Csyntax.cmx Csharpminor.cmx Cminor.cmx CString.cmx CList.cmx Ascii.cmx \
+ AST.cmx Cshmgen.cmi
+Csyntax.cmo: Zmax.cmi Specif.cmi Integers.cmi Floats.cmi Errors.cmi \
+ Datatypes.cmi Coqlib.cmi CString.cmi CList.cmi BinPos.cmi BinInt.cmi \
+ Ascii.cmi AST.cmi Csyntax.cmi
+Csyntax.cmx: Zmax.cmx Specif.cmx Integers.cmx Floats.cmx Errors.cmx \
+ Datatypes.cmx Coqlib.cmx CString.cmx CList.cmx BinPos.cmx BinInt.cmx \
+ Ascii.cmx AST.cmx Csyntax.cmi
Ctyping.cmo: Specif.cmi Maps.cmi Datatypes.cmi Csyntax.cmi Coqlib.cmi \
CList.cmi AST.cmi Ctyping.cmi
Ctyping.cmx: Specif.cmx Maps.cmx Datatypes.cmx Csyntax.cmx Coqlib.cmx \
CList.cmx AST.cmx Ctyping.cmi
Datatypes.cmo: Datatypes.cmi
Datatypes.cmx: Datatypes.cmi
+EqNat.cmo: Specif.cmi Datatypes.cmi EqNat.cmi
+EqNat.cmx: Specif.cmx Datatypes.cmx EqNat.cmi
+Errors.cmo: Datatypes.cmi CString.cmi CList.cmi BinPos.cmi Errors.cmi
+Errors.cmx: Datatypes.cmx CString.cmx CList.cmx BinPos.cmx Errors.cmi
FSetAVL.cmo: Wf.cmi Specif.cmi Peano.cmi OrderedType.cmi FSetList.cmi \
Datatypes.cmi CList.cmi CInt.cmi BinPos.cmi BinInt.cmi FSetAVL.cmi
FSetAVL.cmx: Wf.cmx Specif.cmx Peano.cmx OrderedType.cmx FSetList.cmx \
@@ -299,58 +335,60 @@ Iteration.cmo: Wf.cmi Specif.cmi Datatypes.cmi Coqlib.cmi BinPos.cmi \
Iteration.cmi
Iteration.cmx: Wf.cmx Specif.cmx Datatypes.cmx Coqlib.cmx BinPos.cmx \
Iteration.cmi
-Kildall.cmo: Specif.cmi Setoid.cmi OrderedType.cmi Maps.cmi Lattice.cmi \
- Iteration.cmi FSetFacts.cmi FSetAVL.cmi Datatypes.cmi Coqlib.cmi \
- CList.cmi BinPos.cmi BinInt.cmi Kildall.cmi
-Kildall.cmx: Specif.cmx Setoid.cmx OrderedType.cmx Maps.cmx Lattice.cmx \
- Iteration.cmx FSetFacts.cmx FSetAVL.cmx Datatypes.cmx Coqlib.cmx \
- CList.cmx BinPos.cmx BinInt.cmx Kildall.cmi
-LTL.cmo: Values.cmi Specif.cmi Op.cmi Maps.cmi Locations.cmi Integers.cmi \
- Globalenvs.cmi Datatypes.cmi Conventions.cmi CList.cmi BinPos.cmi \
- BinInt.cmi AST.cmi LTL.cmi
-LTL.cmx: Values.cmx Specif.cmx Op.cmx Maps.cmx Locations.cmx Integers.cmx \
- Globalenvs.cmx Datatypes.cmx Conventions.cmx CList.cmx BinPos.cmx \
- BinInt.cmx AST.cmx LTL.cmi
+Kildall.cmo: Specif.cmi Setoid.cmi OrderedType.cmi Ordered.cmi Maps.cmi \
+ Lattice.cmi Iteration.cmi FSetFacts.cmi FSetAVL.cmi Datatypes.cmi \
+ Coqlib.cmi CList.cmi BinPos.cmi BinInt.cmi Kildall.cmi
+Kildall.cmx: Specif.cmx Setoid.cmx OrderedType.cmx Ordered.cmx Maps.cmx \
+ Lattice.cmx Iteration.cmx FSetFacts.cmx FSetAVL.cmx Datatypes.cmx \
+ Coqlib.cmx CList.cmx BinPos.cmx BinInt.cmx Kildall.cmi
+LTL.cmo: Values.cmi Specif.cmi Op.cmi Mem.cmi Maps.cmi Locations.cmi \
+ Integers.cmi Globalenvs.cmi Datatypes.cmi Conventions.cmi CList.cmi \
+ BinPos.cmi BinInt.cmi AST.cmi LTL.cmi
+LTL.cmx: Values.cmx Specif.cmx Op.cmx Mem.cmx Maps.cmx Locations.cmx \
+ Integers.cmx Globalenvs.cmx Datatypes.cmx Conventions.cmx CList.cmx \
+ BinPos.cmx BinInt.cmx AST.cmx LTL.cmi
+LTLin.cmo: Values.cmi Specif.cmi Op.cmi Mem.cmi Locations.cmi Integers.cmi \
+ Globalenvs.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi BinInt.cmi \
+ AST.cmi LTLin.cmi
+LTLin.cmx: Values.cmx Specif.cmx Op.cmx Mem.cmx Locations.cmx Integers.cmx \
+ Globalenvs.cmx Datatypes.cmx Coqlib.cmx CList.cmx BinPos.cmx BinInt.cmx \
+ AST.cmx LTLin.cmi
Lattice.cmo: Specif.cmi Maps.cmi FSetInterface.cmi Datatypes.cmi Bool.cmi \
BinPos.cmi Lattice.cmi
Lattice.cmx: Specif.cmx Maps.cmx FSetInterface.cmx Datatypes.cmx Bool.cmx \
BinPos.cmx Lattice.cmi
-Linear.cmo: Values.cmi Specif.cmi Op.cmi Locations.cmi Integers.cmi \
+Linear.cmo: Values.cmi Specif.cmi Op.cmi Mem.cmi Locations.cmi Integers.cmi \
Globalenvs.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi BinInt.cmi \
AST.cmi Linear.cmi
-Linear.cmx: Values.cmx Specif.cmx Op.cmx Locations.cmx Integers.cmx \
+Linear.cmx: Values.cmx Specif.cmx Op.cmx Mem.cmx Locations.cmx Integers.cmx \
Globalenvs.cmx Datatypes.cmx Coqlib.cmx CList.cmx BinPos.cmx BinInt.cmx \
AST.cmx Linear.cmi
-Linearize.cmo: Specif.cmi Op.cmi Maps.cmi Linear.cmi Lattice.cmi LTL.cmi \
+Linearize.cmo: Specif.cmi Op.cmi Maps.cmi Lattice.cmi LTLin.cmi LTL.cmi \
Kildall.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi AST.cmi \
Linearize.cmi
-Linearize.cmx: Specif.cmx Op.cmx Maps.cmx Linear.cmx Lattice.cmx LTL.cmx \
+Linearize.cmx: Specif.cmx Op.cmx Maps.cmx Lattice.cmx LTLin.cmx LTL.cmx \
Kildall.cmx Datatypes.cmx Coqlib.cmx CList.cmx BinPos.cmx AST.cmx \
Linearize.cmi
-Lineartyping.cmo: Zmax.cmi Locations.cmi Linear.cmi Datatypes.cmi \
- Conventions.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi Lineartyping.cmi
-Lineartyping.cmx: Zmax.cmx Locations.cmx Linear.cmx Datatypes.cmx \
- Conventions.cmx CList.cmx BinPos.cmx BinInt.cmx AST.cmx Lineartyping.cmi
Locations.cmo: Values.cmi Specif.cmi Datatypes.cmi Coqlib.cmi BinPos.cmi \
BinInt.cmi AST.cmi Locations.cmi
Locations.cmx: Values.cmx Specif.cmx Datatypes.cmx Coqlib.cmx BinPos.cmx \
BinInt.cmx AST.cmx Locations.cmi
Logic.cmo: Logic.cmi
Logic.cmx: Logic.cmi
-Mach.cmo: Zmax.cmi Zdiv.cmi Values.cmi Specif.cmi Op.cmi Mem.cmi Maps.cmi \
+Mach.cmo: Zmax.cmi Zdiv.cmi Values.cmi Specif.cmi Op.cmi Maps.cmi \
Locations.cmi Integers.cmi Globalenvs.cmi Datatypes.cmi Coqlib.cmi \
CList.cmi BinPos.cmi BinInt.cmi AST.cmi Mach.cmi
-Mach.cmx: Zmax.cmx Zdiv.cmx Values.cmx Specif.cmx Op.cmx Mem.cmx Maps.cmx \
+Mach.cmx: Zmax.cmx Zdiv.cmx Values.cmx Specif.cmx Op.cmx Maps.cmx \
Locations.cmx Integers.cmx Globalenvs.cmx Datatypes.cmx Coqlib.cmx \
CList.cmx BinPos.cmx BinInt.cmx AST.cmx Mach.cmi
-Main.cmo: Tunneling.cmi Stacking.cmi RTLgen.cmi PPCgen.cmi PPC.cmi \
- Linearize.cmi Datatypes.cmi Ctyping.cmi Csyntax.cmi Cshmgen.cmi \
- Constprop.cmi Cminorgen.cmi Cminor.cmi CSE.cmi Allocation.cmi AST.cmi \
- Main.cmi
-Main.cmx: Tunneling.cmx Stacking.cmx RTLgen.cmx PPCgen.cmx PPC.cmx \
- Linearize.cmx Datatypes.cmx Ctyping.cmx Csyntax.cmx Cshmgen.cmx \
- Constprop.cmx Cminorgen.cmx Cminor.cmx CSE.cmx Allocation.cmx AST.cmx \
- Main.cmi
+Main.cmo: Tunneling.cmi Stacking.cmi Selection.cmi Reload.cmi RTLgen.cmi \
+ RTL.cmi PPCgen.cmi PPC.cmi Linearize.cmi Errors.cmi Datatypes.cmi \
+ Ctyping.cmi Csyntax.cmi Cshmgen.cmi Constprop.cmi Cminorgen.cmi \
+ Cminor.cmi CString.cmi CSE.cmi Ascii.cmi Allocation.cmi AST.cmi Main.cmi
+Main.cmx: Tunneling.cmx Stacking.cmx Selection.cmx Reload.cmx RTLgen.cmx \
+ RTL.cmx PPCgen.cmx PPC.cmx Linearize.cmx Errors.cmx Datatypes.cmx \
+ Ctyping.cmx Csyntax.cmx Cshmgen.cmx Constprop.cmx Cminorgen.cmx \
+ Cminor.cmx CString.cmx CSE.cmx Ascii.cmx Allocation.cmx AST.cmx Main.cmi
Maps.cmo: Specif.cmi Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi BinNat.cmi \
BinInt.cmi Maps.cmi
Maps.cmx: Specif.cmx Datatypes.cmx Coqlib.cmx CList.cmx BinPos.cmx BinNat.cmx \
@@ -359,9 +397,9 @@ Mem.cmo: Zmax.cmi Values.cmi Specif.cmi Integers.cmi Datatypes.cmi Coqlib.cmi \
CList.cmi BinPos.cmi BinInt.cmi AST.cmi Mem.cmi
Mem.cmx: Zmax.cmx Values.cmx Specif.cmx Integers.cmx Datatypes.cmx Coqlib.cmx \
CList.cmx BinPos.cmx BinInt.cmx AST.cmx Mem.cmi
-Op.cmo: Values.cmi Specif.cmi Integers.cmi Globalenvs.cmi Floats.cmi \
+Op.cmo: Values.cmi Specif.cmi Mem.cmi Integers.cmi Globalenvs.cmi Floats.cmi \
Datatypes.cmi CList.cmi Bool.cmi BinPos.cmi BinInt.cmi AST.cmi Op.cmi
-Op.cmx: Values.cmx Specif.cmx Integers.cmx Globalenvs.cmx Floats.cmx \
+Op.cmx: Values.cmx Specif.cmx Mem.cmx Integers.cmx Globalenvs.cmx Floats.cmx \
Datatypes.cmx CList.cmx Bool.cmx BinPos.cmx BinInt.cmx AST.cmx Op.cmi
Ordered.cmo: Specif.cmi OrderedType.cmi Maps.cmi Datatypes.cmi Coqlib.cmi \
BinPos.cmi Ordered.cmi
@@ -376,11 +414,11 @@ PPC.cmx: Values.cmx Specif.cmx Mem.cmx Maps.cmx Integers.cmx Globalenvs.cmx \
Floats.cmx Datatypes.cmx Coqlib.cmx CList.cmx BinPos.cmx BinInt.cmx \
AST.cmx PPC.cmi
PPCgen.cmo: Specif.cmi PPC.cmi Op.cmi Mach.cmi Locations.cmi Integers.cmi \
- Datatypes.cmi Coqlib.cmi CList.cmi Bool.cmi BinPos.cmi BinInt.cmi AST.cmi \
- PPCgen.cmi
+ Errors.cmi Datatypes.cmi Coqlib.cmi CString.cmi CList.cmi Bool.cmi \
+ BinPos.cmi BinInt.cmi Ascii.cmi AST.cmi PPCgen.cmi
PPCgen.cmx: Specif.cmx PPC.cmx Op.cmx Mach.cmx Locations.cmx Integers.cmx \
- Datatypes.cmx Coqlib.cmx CList.cmx Bool.cmx BinPos.cmx BinInt.cmx AST.cmx \
- PPCgen.cmi
+ Errors.cmx Datatypes.cmx Coqlib.cmx CString.cmx CList.cmx Bool.cmx \
+ BinPos.cmx BinInt.cmx Ascii.cmx AST.cmx PPCgen.cmi
Parallelmove.cmo: Parmov.cmi Locations.cmi Datatypes.cmi CList.cmi AST.cmi \
Parallelmove.cmi
Parallelmove.cmx: Parmov.cmx Locations.cmx Datatypes.cmx CList.cmx AST.cmx \
@@ -389,38 +427,60 @@ Parmov.cmo: Specif.cmi Peano.cmi Datatypes.cmi CList.cmi Parmov.cmi
Parmov.cmx: Specif.cmx Peano.cmx Datatypes.cmx CList.cmx Parmov.cmi
Peano.cmo: Datatypes.cmi Peano.cmi
Peano.cmx: Datatypes.cmx Peano.cmi
-RTL.cmo: Values.cmi Registers.cmi Op.cmi Maps.cmi Integers.cmi Globalenvs.cmi \
- Datatypes.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi RTL.cmi
-RTL.cmx: Values.cmx Registers.cmx Op.cmx Maps.cmx Integers.cmx Globalenvs.cmx \
- Datatypes.cmx CList.cmx BinPos.cmx BinInt.cmx AST.cmx RTL.cmi
-RTLgen.cmo: Specif.cmi Registers.cmi ../caml/RTLgenaux.cmo RTL.cmi Op.cmi \
- Maps.cmi Integers.cmi Datatypes.cmi Coqlib.cmi Cminor.cmi CList.cmi \
- BinPos.cmi AST.cmi RTLgen.cmi
-RTLgen.cmx: Specif.cmx Registers.cmx ../caml/RTLgenaux.cmx RTL.cmx Op.cmx \
- Maps.cmx Integers.cmx Datatypes.cmx Coqlib.cmx Cminor.cmx CList.cmx \
- BinPos.cmx AST.cmx RTLgen.cmi
+RTL.cmo: Values.cmi Registers.cmi Op.cmi Mem.cmi Maps.cmi Integers.cmi \
+ Globalenvs.cmi Datatypes.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi \
+ RTL.cmi
+RTL.cmx: Values.cmx Registers.cmx Op.cmx Mem.cmx Maps.cmx Integers.cmx \
+ Globalenvs.cmx Datatypes.cmx CList.cmx BinPos.cmx BinInt.cmx AST.cmx \
+ RTL.cmi
+RTLgen.cmo: Switch.cmi Specif.cmi Registers.cmi ../caml/RTLgenaux.cmo RTL.cmi \
+ Op.cmi Maps.cmi Integers.cmi Errors.cmi Datatypes.cmi Coqlib.cmi \
+ CminorSel.cmi CString.cmi CList.cmi BinPos.cmi Ascii.cmi AST.cmi \
+ RTLgen.cmi
+RTLgen.cmx: Switch.cmx Specif.cmx Registers.cmx ../caml/RTLgenaux.cmx RTL.cmx \
+ Op.cmx Maps.cmx Integers.cmx Errors.cmx Datatypes.cmx Coqlib.cmx \
+ CminorSel.cmx CString.cmx CList.cmx BinPos.cmx Ascii.cmx AST.cmx \
+ RTLgen.cmi
RTLtyping.cmo: Specif.cmi Registers.cmi ../caml/RTLtypingaux.cmo RTL.cmi \
- Op.cmi Maps.cmi Datatypes.cmi Coqlib.cmi CList.cmi AST.cmi RTLtyping.cmi
+ Op.cmi Maps.cmi Errors.cmi Datatypes.cmi Coqlib.cmi Conventions.cmi \
+ CString.cmi CList.cmi BinPos.cmi BinInt.cmi Ascii.cmi AST.cmi \
+ RTLtyping.cmi
RTLtyping.cmx: Specif.cmx Registers.cmx ../caml/RTLtypingaux.cmx RTL.cmx \
- Op.cmx Maps.cmx Datatypes.cmx Coqlib.cmx CList.cmx AST.cmx RTLtyping.cmi
+ Op.cmx Maps.cmx Errors.cmx Datatypes.cmx Coqlib.cmx Conventions.cmx \
+ CString.cmx CList.cmx BinPos.cmx BinInt.cmx Ascii.cmx AST.cmx \
+ RTLtyping.cmi
Registers.cmo: Specif.cmi OrderedType.cmi Ordered.cmi Maps.cmi FSetAVL.cmi \
Datatypes.cmi Coqlib.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi \
Registers.cmi
Registers.cmx: Specif.cmx OrderedType.cmx Ordered.cmx Maps.cmx FSetAVL.cmx \
Datatypes.cmx Coqlib.cmx CList.cmx BinPos.cmx BinInt.cmx AST.cmx \
Registers.cmi
+Reload.cmo: Specif.cmi Parallelmove.cmi Op.cmi Locations.cmi Linear.cmi \
+ LTLin.cmi Datatypes.cmi Conventions.cmi CList.cmi AST.cmi Reload.cmi
+Reload.cmx: Specif.cmx Parallelmove.cmx Op.cmx Locations.cmx Linear.cmx \
+ LTLin.cmx Datatypes.cmx Conventions.cmx CList.cmx AST.cmx Reload.cmi
+Selection.cmo: Specif.cmi Op.cmi Integers.cmi Datatypes.cmi Compare_dec.cmi \
+ CminorSel.cmi Cminor.cmi CList.cmi BinPos.cmi BinInt.cmi AST.cmi \
+ Selection.cmi
+Selection.cmx: Specif.cmx Op.cmx Integers.cmx Datatypes.cmx Compare_dec.cmx \
+ CminorSel.cmx Cminor.cmx CList.cmx BinPos.cmx BinInt.cmx AST.cmx \
+ Selection.cmi
Setoid.cmo: Datatypes.cmi Setoid.cmi
Setoid.cmx: Datatypes.cmx Setoid.cmi
Specif.cmo: Datatypes.cmi Specif.cmi
Specif.cmx: Datatypes.cmx Specif.cmi
-Stacking.cmo: Specif.cmi Op.cmi Mach.cmi Locations.cmi Lineartyping.cmi \
- Linear.cmi Integers.cmi Datatypes.cmi Coqlib.cmi Conventions.cmi \
- CList.cmi BinPos.cmi BinInt.cmi AST.cmi Stacking.cmi
-Stacking.cmx: Specif.cmx Op.cmx Mach.cmx Locations.cmx Lineartyping.cmx \
- Linear.cmx Integers.cmx Datatypes.cmx Coqlib.cmx Conventions.cmx \
- CList.cmx BinPos.cmx BinInt.cmx AST.cmx Stacking.cmi
+Stacking.cmo: Specif.cmi Op.cmi Mach.cmi Locations.cmi Linear.cmi \
+ Integers.cmi Errors.cmi Datatypes.cmi Coqlib.cmi Conventions.cmi \
+ CString.cmi CList.cmi Bounds.cmi BinPos.cmi BinInt.cmi Ascii.cmi AST.cmi \
+ Stacking.cmi
+Stacking.cmx: Specif.cmx Op.cmx Mach.cmx Locations.cmx Linear.cmx \
+ Integers.cmx Errors.cmx Datatypes.cmx Coqlib.cmx Conventions.cmx \
+ CString.cmx CList.cmx Bounds.cmx BinPos.cmx BinInt.cmx Ascii.cmx AST.cmx \
+ Stacking.cmi
Sumbool.cmo: Specif.cmi Datatypes.cmi Sumbool.cmi
Sumbool.cmx: Specif.cmx Datatypes.cmx Sumbool.cmi
+Switch.cmo: Integers.cmi EqNat.cmi Datatypes.cmi CList.cmi Switch.cmi
+Switch.cmx: Integers.cmx EqNat.cmx Datatypes.cmx CList.cmx Switch.cmi
Tunneling.cmo: Maps.cmi LTL.cmi Datatypes.cmi AST.cmi Tunneling.cmi
Tunneling.cmx: Maps.cmx LTL.cmx Datatypes.cmx AST.cmx Tunneling.cmi
Values.cmo: Specif.cmi Integers.cmi Floats.cmi Datatypes.cmi Coqlib.cmi \
diff --git a/extraction/Makefile b/extraction/Makefile
index 69b5f572e853f4b03a8b6fd8cf64e9ca74d7011e..cb7f4c5a830ec1dd2eb47209f46504f10ade13f6 100644
--- a/extraction/Makefile
+++ b/extraction/Makefile
@@ -1,32 +1,36 @@
FILES=\
- Datatypes.ml Logic.ml Wf.ml Peano.ml Specif.ml Compare_dec.ml \
+ Datatypes.ml Logic.ml Wf.ml Peano.ml Specif.ml Compare_dec.ml EqNat.ml \
Bool.ml CList.ml Sumbool.ml Setoid.ml BinPos.ml BinNat.ml BinInt.ml \
ZArith_dec.ml Zeven.ml Zmax.ml Zmisc.ml Zbool.ml Zpower.ml Zdiv.ml \
+ Ascii.ml CString.ml \
OrderedType.ml FSetInterface.ml FSetFacts.ml FSetList.ml \
CInt.ml FSetAVL.ml \
- Coqlib.ml Maps.ml Ordered.ml AST.ml Iteration.ml Integers.ml \
+ Coqlib.ml Maps.ml Ordered.ml Errors.ml AST.ml Iteration.ml Integers.ml \
../caml/Camlcoq.ml ../caml/Floataux.ml Floats.ml Parmov.ml Values.ml \
Mem.ml Globalenvs.ml \
- Csyntax.ml Ctyping.ml Csharpminor.ml Cshmgen.ml \
- Op.ml Cminor.ml Cmconstr.ml \
+ Csyntax.ml Ctyping.ml Cminor.ml Csharpminor.ml Cshmgen.ml \
Cminorgen.ml \
+ Op.ml CminorSel.ml \
+ Selection.ml \
Registers.ml RTL.ml \
- ../caml/RTLgenaux.ml RTLgen.ml \
+ Switch.ml ../caml/RTLgenaux.ml RTLgen.ml \
Locations.ml Conventions.ml \
../caml/RTLtypingaux.ml RTLtyping.ml \
Lattice.ml Kildall.ml \
Constprop.ml CSE.ml \
- LTL.ml \
+ LTL.ml LTLin.ml \
InterfGraph.ml ../caml/Coloringaux.ml Coloring.ml \
- Parallelmove.ml Allocation.ml \
- Tunneling.ml Linear.ml Lineartyping.ml Linearize.ml \
- Mach.ml Stacking.ml \
+ Allocation.ml \
+ Tunneling.ml Linear.ml Linearize.ml \
+ Parallelmove.ml Reload.ml \
+ Mach.ml Bounds.ml Stacking.ml \
PPC.ml PPCgen.ml \
Main.ml \
../caml/Cil2Csyntax.ml \
../caml/CMparser.ml ../caml/CMlexer.ml ../caml/CMtypecheck.ml \
../caml/PrintCsyntax.ml ../caml/PrintPPC.ml \
../caml/Main2.ml
+# ../caml/Configuration.ml ../caml/Driver.ml
EXTRACTEDFILES:=$(filter-out ../caml/%, $(FILES))
GENFILES:=$(EXTRACTEDFILES) $(EXTRACTEDFILES:.ml=.mli)
@@ -58,13 +62,15 @@ extraction:
@echo "Fixing file names..."
@mv list.ml CList.ml
@mv list.mli CList.mli
+ @mv string.ml CString.ml
+ @mv string.mli CString.mli
@mv int.ml CInt.ml
@mv int.mli CInt.mli
@for i in $(GENFILES); do \
j=`./uncapitalize $$i`; \
test -f $$i || (test -f $$j && mv $$j $$i); \
done
- @echo "Conversion List -> CList and Int -> CInt..."
+ @echo "Conversion List -> CList, String -> CString, Int -> CInt..."
@./convert $(GENFILES)
@echo "Patching files..."
@for i in *.patch; do patch < $$i; done
diff --git a/extraction/convert b/extraction/convert
index a29178a12ee5c26bafbb4f8e7aace19f02a4b9e3..b3d253360e37db08d94d569cc834c4013ac5fc5f 100755
--- a/extraction/convert
+++ b/extraction/convert
@@ -1,6 +1,7 @@
#!/usr/bin/perl -pi
s/\bList\b/CList/g;
+s/\bString\b/CString/g;
s/\bInt\.Z_as_Int\b/CInt.Z_as_Int/g;
s/\bInt\.Int\b/CInt.Int/g;
s/\bInt\.MoreInt\b/CInt.MoreInt/g;
diff --git a/extraction/extraction.v b/extraction/extraction.v
index 47c6f36cd915508439a9f43762d805d5bc5e9692..cc33c981c6e0d7a1f2360b8e9aeba15a42f2b69b 100644
--- a/extraction/extraction.v
+++ b/extraction/extraction.v
@@ -38,6 +38,7 @@ Extract Constant Iteration.GenIter.iterate =>
(* RTLgen *)
+Extract Constant RTLgen.compile_switch => "RTLgenaux.compile_switch".
Extract Constant RTLgen.more_likely => "RTLgenaux.more_likely".
(* RTLtyping *)
diff --git a/lib/Coqlib.v b/lib/Coqlib.v
index 184fe28f324037df5dda798c0616ad152e02d9d1..7bee366b12c48f343bc8eabc64bbd3d37fdace11 100644
--- a/lib/Coqlib.v
+++ b/lib/Coqlib.v
@@ -23,6 +23,8 @@ Axiom proof_irrelevance:
(** * Useful tactics *)
+Ltac inv H := inversion H; clear H; subst.
+
Ltac predSpec pred predspec x y :=
generalize (predspec x y); case (pred x y); intro.
@@ -753,6 +755,44 @@ Proof.
generalize list_norepet_app; firstorder.
Qed.
+(** [is_tail l1 l2] holds iff [l2] is of the form [l ++ l1] for some [l]. *)
+
+Inductive is_tail (A: Set): list A -> list A -> Prop :=
+ | is_tail_refl:
+ forall c, is_tail c c
+ | is_tail_cons:
+ forall i c1 c2, is_tail c1 c2 -> is_tail c1 (i :: c2).
+
+Lemma is_tail_in:
+ forall (A: Set) (i: A) c1 c2, is_tail (i :: c1) c2 -> In i c2.
+Proof.
+ induction c2; simpl; intros.
+ inversion H.
+ inversion H. tauto. right; auto.
+Qed.
+
+Lemma is_tail_cons_left:
+ forall (A: Set) (i: A) c1 c2, is_tail (i :: c1) c2 -> is_tail c1 c2.
+Proof.
+ induction c2; intros; inversion H.
+ constructor. constructor. constructor. auto.
+Qed.
+
+Hint Resolve is_tail_refl is_tail_cons is_tail_in is_tail_cons_left: coqlib.
+
+Lemma is_tail_incl:
+ forall (A: Set) (l1 l2: list A), is_tail l1 l2 -> incl l1 l2.
+Proof.
+ induction 1; eauto with coqlib.
+Qed.
+
+Lemma is_tail_trans:
+ forall (A: Set) (l1 l2: list A),
+ is_tail l1 l2 -> forall (l3: list A), is_tail l2 l3 -> is_tail l1 l3.
+Proof.
+ induction 1; intros. auto. apply IHis_tail. eapply is_tail_cons_left; eauto.
+Qed.
+
(** [list_forall2 P [x1 ... xN] [y1 ... yM] holds iff [N = M] and
[P xi yi] holds for all [i]. *)
diff --git a/lib/Iteration.v b/lib/Iteration.v
index 3c4b5998c89625de9c2ac9aaecba6ed5c4325e83..85c5ded8dec61d9860a62c8013b5149692017426 100644
--- a/lib/Iteration.v
+++ b/lib/Iteration.v
@@ -1,6 +1,5 @@
(* Bounded and unbounded iterators *)
-Require Recdef.
Require Import Coqlib.
Require Import Classical.
Require Import Max.
@@ -72,15 +71,51 @@ Fixpoint iterate (a: A) : B :=
Definition num_iterations := 1000000000000%positive.
-Function iter (niter: positive) (s: A) {wf Plt niter} : option B :=
- if peq niter xH then None else
- match step s with
- | inl res => Some res
- | inr s' => iter (Ppred niter) s'
- end.
+(** The simple definition of bounded iteration is:
+<<
+Fixpoint iterate (niter: nat) (a: A) {struct niter} : option B :=
+ match niter with
+ | O => None
+ | S niter' =>
+ match step a with
+ | inl b => b
+ | inr a' => iterate niter' a'
+ end
+ end.
+>>
+ This function is structural recursive over the parameter [niter]
+ (number of iterations), represented here as a Peano integer (type [nat]).
+ However, we want to use very large values of [niter]. As Peano integers,
+ these values would be much too large to fit in memory. Therefore,
+ we must express iteration counts as a binary integer (type [positive]).
+ However, Peano induction over type [positive] is not structural recursion,
+ so we cannot define [iterate] as a Coq fixpoint and must use
+ Noetherian recursion instead. *)
+
+Definition iter_step (x: positive)
+ (next: forall y, Plt y x -> A -> option B)
+ (s: A) : option B :=
+ match peq x xH with
+ | left EQ => None
+ | right NOTEQ =>
+ match step s with
+ | inl res => Some res
+ | inr s' => next (Ppred x) (Ppred_Plt x NOTEQ) s'
+ end
+ end.
+
+Definition iter: positive -> A -> option B :=
+ Fix Plt_wf (fun _ => A -> option B) iter_step.
+
+(** We then prove the expected unrolling equations for [iter]. *)
+
+Remark unroll_iter:
+ forall x, iter x = iter_step x (fun y _ => iter y).
Proof.
- intros. apply Ppred_Plt. auto.
- apply Plt_wf.
+ unfold iter; apply (Fix_eq Plt_wf (fun _ => A -> option B) iter_step).
+ intros. unfold iter_step. apply extensionality. intro s.
+ case (peq x xH); intro. auto.
+ rewrite H. auto.
Qed.
(** The [iterate] function is defined as [iter] up to
@@ -100,10 +135,13 @@ Hypothesis step_prop:
Lemma iter_prop:
forall n a b, P a -> iter n a = Some b -> Q b.
Proof.
- intros n a. functional induction (iter n a); intros.
- discriminate.
- inversion H0; subst b. generalize (step_prop s H). rewrite e0. auto.
- apply IHo. generalize (step_prop s H). rewrite e0. auto. auto.
+ apply (well_founded_ind Plt_wf
+ (fun p => forall a b, P a -> iter p a = Some b -> Q b)).
+ intros until b. intro. rewrite unroll_iter.
+ unfold iter_step. case (peq x 1); intro. congruence.
+ generalize (step_prop a H0).
+ case (step a); intros. congruence.
+ apply H with (Ppred x) a0. apply Ppred_Plt; auto. auto. auto.
Qed.
Lemma iterate_prop:
diff --git a/lib/Parmov.v b/lib/Parmov.v
index cd24dd96675c704189e0d5f546ee79c155801aa7..c244b8b6b4fa8b4a9738a004db22884620dd05c1 100644
--- a/lib/Parmov.v
+++ b/lib/Parmov.v
@@ -34,30 +34,57 @@
#</A>#
*)
+Require Import Relations.
Require Import Coqlib.
Require Recdef.
Section PARMOV.
+(** * Registers, moves, and their semantics *)
+
+(** The development is parameterized by the type of registers,
+ equipped with a decidable equality. *)
+
Variable reg: Set.
+Variable reg_eq : forall (r1 r2: reg), {r1=r2} + {r1<>r2}.
+
+(** The [temp] function maps every register [r] to the register that
+ should be used to save the value of [r] temporarily while performing
+ a cyclic assignment involving [r]. In the simplest case, there is
+ only one such temporary register [rtemp] and [temp] is the constant
+ function [fun r => rtemp]. In more realistic cases, different temporary
+ registers can be used to hold different values. In the case of Compcert,
+ we have two temporary registers, one for integer values and the other
+ for floating-point values, and [temp] returns the appropriate temporary
+ depending on the type of its argument. *)
+
Variable temp: reg -> reg.
+(** A set of moves is a list of pairs of registers, of the form
+ (source, destination). *)
+
Definition moves := (list (reg * reg))%type. (* src -> dst *)
Definition srcs (m: moves) := List.map (@fst reg reg) m.
Definition dests (m: moves) := List.map (@snd reg reg) m.
-(* Semantics of moves *)
+(** ** Semantics of moves *)
+
+(** The dynamic semantics of moves is given in terms of environments.
+ An environment is a mapping of registers to their current values. *)
Variable val: Set.
Definition env := reg -> val.
-Variable reg_eq : forall (r1 r2: reg), {r1=r2} + {r1<>r2}.
Lemma env_ext:
forall (e1 e2: env),
(forall r, e1 r = e2 r) -> e1 = e2.
Proof (extensionality reg val).
+(** The main operation over environments is update: it assigns
+ a value [v] to a register [r] and preserves the values of other
+ registers. *)
+
Definition update (r: reg) (v: val) (e: env) : env :=
fun r' => if reg_eq r' r then v else e r'.
@@ -97,18 +124,32 @@ Proof.
destruct (reg_eq r0 r); auto.
Qed.
+(** A list of moves [(src1, dst1), ..., (srcN, dstN)] can be given
+ three different semantics, as environment transformers.
+ The first semantics corresponds to a parallel assignment:
+ [dst1, ..., dstN] are set to the initial values of [src1, ..., srcN]. *)
+
Fixpoint exec_par (m: moves) (e: env) {struct m}: env :=
match m with
| nil => e
| (s, d) :: m' => update d (e s) (exec_par m' e)
end.
+(** The second semantics corresponds to a sequence of individual
+ assignments: first, [dst1] is set to the initial value of [src1];
+ then, [dst2] is set to the current value of [src2] after the first
+ assignment; etc. *)
+
Fixpoint exec_seq (m: moves) (e: env) {struct m}: env :=
match m with
| nil => e
| (s, d) :: m' => exec_seq m' (update d (e s) e)
end.
+(** The third semantics is also sequential, but executes the moves
+ in reverse order, starting with [srcN, dstN] and finishing with
+ [src1, dst1]. *)
+
Fixpoint exec_seq_rev (m: moves) (e: env) {struct m}: env :=
match m with
| nil => e
@@ -117,50 +158,57 @@ Fixpoint exec_seq_rev (m: moves) (e: env) {struct m}: env :=
update d (e' s) e'
end.
-(* Specification of the parallel move *)
+(** * Specification of the non-deterministic algorithm *)
+
+(** Rideau and Serpette's parallel move compilation algorithm is first
+ specified as a non-deterministic set of rewriting rules operating
+ over triples [(mu, sigma, tau)] of moves. We define these rules
+ as an inductive predicate [transition] relating triples of moves,
+ and its reflexive transitive closure [transitions]. *)
+
+Inductive state: Set :=
+ State (mu: moves) (sigma: moves) (tau: moves) : state.
Definition no_read (mu: moves) (d: reg) : Prop :=
~In d (srcs mu).
-Inductive transition: moves -> moves -> moves
- -> moves -> moves -> moves -> Prop :=
+Inductive transition: state -> state -> Prop :=
| tr_nop: forall mu1 r mu2 sigma tau,
- transition (mu1 ++ (r, r) :: mu2) sigma tau
- (mu1 ++ mu2) sigma tau
+ transition (State (mu1 ++ (r, r) :: mu2) sigma tau)
+ (State (mu1 ++ mu2) sigma tau)
| tr_start: forall mu1 s d mu2 tau,
- transition (mu1 ++ (s, d) :: mu2) nil tau
- (mu1 ++ mu2) ((s, d) :: nil) tau
+ transition (State (mu1 ++ (s, d) :: mu2) nil tau)
+ (State (mu1 ++ mu2) ((s, d) :: nil) tau)
| tr_push: forall mu1 d r mu2 s sigma tau,
- transition (mu1 ++ (d, r) :: mu2) ((s, d) :: sigma) tau
- (mu1 ++ mu2) ((d, r) :: (s, d) :: sigma) tau
+ transition (State (mu1 ++ (d, r) :: mu2) ((s, d) :: sigma) tau)
+ (State (mu1 ++ mu2) ((d, r) :: (s, d) :: sigma) tau)
| tr_loop: forall mu sigma s d tau,
- transition mu (sigma ++ (s, d) :: nil) tau
- mu (sigma ++ (temp s, d) :: nil) ((s, temp s) :: tau)
+ transition (State mu (sigma ++ (s, d) :: nil) tau)
+ (State mu (sigma ++ (temp s, d) :: nil) ((s, temp s) :: tau))
| tr_pop: forall mu s0 d0 s1 d1 sigma tau,
no_read mu d1 -> d1 <> s0 ->
- transition mu ((s1, d1) :: sigma ++ (s0, d0) :: nil) tau
- mu (sigma ++ (s0, d0) :: nil) ((s1, d1) :: tau)
+ transition (State mu ((s1, d1) :: sigma ++ (s0, d0) :: nil) tau)
+ (State mu (sigma ++ (s0, d0) :: nil) ((s1, d1) :: tau))
| tr_last: forall mu s d tau,
no_read mu d ->
- transition mu ((s, d) :: nil) tau
- mu nil ((s, d) :: tau).
+ transition (State mu ((s, d) :: nil) tau)
+ (State mu nil ((s, d) :: tau)).
-Inductive transitions: moves -> moves -> moves
- -> moves -> moves -> moves -> Prop :=
- | tr_refl:
- forall mu sigma tau,
- transitions mu sigma tau mu sigma tau
- | tr_one:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2,
- transition mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- transitions mu1 sigma1 tau1 mu2 sigma2 tau2
- | tr_trans:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2 mu3 sigma3 tau3,
- transitions mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- transitions mu2 sigma2 tau2 mu3 sigma3 tau3 ->
- transitions mu1 sigma1 tau1 mu3 sigma3 tau3.
-
-(* Well-formedness properties *)
+Definition transitions: state -> state -> Prop :=
+ clos_refl_trans state transition.
+
+(** ** Well-formedness properties of states *)
+
+(** A state [mu, sigma, tau] is well-formed if the following properties hold:
+
+- [mu] concatenated with [sigma] is a ``mill'', that is, no destination
+ appears twice (predicate [is_mill] below).
+- No temporary register appears in [mu] (predicate [move_no_temp]).
+- No temporary register appears in [sigma] except perhaps as the source
+ of the last move in [sigma] (predicate [temp_last]).
+- [sigma] is a ``path'', that is, the source of a move is the destination
+ of the following move.
+*)
Definition is_mill (m: moves) : Prop :=
list_norepet (dests m).
@@ -191,13 +239,16 @@ Inductive is_path: moves -> Prop :=
is_path m ->
is_path ((s, d) :: m).
-Definition state_wf (mu sigma tau: moves) : Prop :=
- is_mill (mu ++ sigma)
- /\ move_no_temp mu
- /\ temp_last sigma
- /\ is_path sigma.
+Inductive state_wf: state -> Prop :=
+ | state_wf_intro:
+ forall mu sigma tau,
+ is_mill (mu ++ sigma) ->
+ move_no_temp mu ->
+ temp_last sigma ->
+ is_path sigma ->
+ state_wf (State mu sigma tau).
-(* Some properties of srcs and dests *)
+(** Some trivial properties of srcs and dests. *)
Lemma dests_append:
forall m1 m2, dests (m1 ++ m2) = dests m1 ++ dests m2.
@@ -236,7 +287,7 @@ Proof.
elim (IHs d); intros. split; congruence. congruence.
Qed.
-(* Some properties of is_mill and dests_disjoint *)
+(** Some properties of [is_mill] and [dests_disjoint]. *)
Definition dests_disjoint (m1 m2: moves) : Prop :=
list_disjoint (dests m1) (dests m2).
@@ -313,7 +364,7 @@ Proof.
apply list_norepet_app.
Qed.
-(* Some properties of move_no_temp *)
+(** Some properties of [move_no_temp]. *)
Lemma move_no_temp_append:
forall m1 m2,
@@ -329,7 +380,7 @@ Proof.
intros; red; intros. apply H. rewrite <- List.In_rev. auto.
Qed.
-(* Some properties of temp_last *)
+(** Some properties of [temp_last]. *)
Lemma temp_last_change_last_source:
forall s d s' sigma,
@@ -369,7 +420,7 @@ Proof.
apply in_or_app. auto.
Qed.
-(* Some properties of is_path *)
+(** Some properties of [is_path]. *)
Lemma is_path_pop:
forall s d m,
@@ -420,7 +471,8 @@ Proof.
intro. elim H1. elim (H2 _ H3); intro. congruence. auto.
Qed.
-(* Populating a rewrite database. *)
+(** To benefit from some proof automation, we populate a rewrite database
+ with some of the properties above. *)
Lemma notin_dests_cons:
forall x s d m,
@@ -441,65 +493,76 @@ Hint Rewrite is_mill_cons is_mill_append
dests_disjoint_append_left dests_disjoint_append_right
notin_dests_cons notin_dests_append: pmov.
-(* Preservation of well-formedness *)
+(** ** Transitions preserve well-formedness *)
Lemma transition_preserves_wf:
- forall mu sigma tau mu' sigma' tau',
- transition mu sigma tau mu' sigma' tau' ->
- state_wf mu sigma tau -> state_wf mu' sigma' tau'.
+ forall st st',
+ transition st st' -> state_wf st -> state_wf st'.
Proof.
- induction 1; unfold state_wf; intros [A [B [C D]]];
- autorewrite with pmov in A; autorewrite with pmov.
+ induction 1; intro WF; inversion WF as [mu0 sigma0 tau0 A B C D];
+ subst;
+ autorewrite with pmov in A; constructor; autorewrite with pmov.
(* Nop *)
- split. tauto.
- split. red; intros. apply B. apply list_in_insert; auto.
- split; auto.
+ tauto.
+ red; intros. apply B. apply list_in_insert; auto.
+ auto. auto.
(* Start *)
- split. tauto.
- split. red; intros. apply B. apply list_in_insert; auto.
- split. red. simpl. split. elim (B s d). auto.
+ tauto.
+ red; intros. apply B. apply list_in_insert; auto.
+ red. simpl. split. elim (B s d). auto.
apply in_or_app. right. apply in_eq.
red; simpl; tauto.
constructor. exact I. constructor.
(* Push *)
- split. intuition.
- split. red; intros. apply B. apply list_in_insert; auto.
- split. elim (B d r). apply temp_last_push; auto.
+ intuition.
+ red; intros. apply B. apply list_in_insert; auto.
+ elim (B d r). apply temp_last_push; auto.
apply in_or_app; right; apply in_eq.
constructor. simpl. auto. auto.
(* Loop *)
- split. tauto.
- split. auto.
- split. eapply temp_last_change_last_source; eauto.
+ tauto.
+ auto.
+ eapply temp_last_change_last_source; eauto.
eapply is_path_change_last_source; eauto.
(* Pop *)
- split. intuition.
- split. auto.
- split. eapply temp_last_pop; eauto.
+ intuition.
+ auto.
+ eapply temp_last_pop; eauto.
eapply is_path_pop; eauto.
(* Last *)
- split. intuition.
- split. auto.
- split. unfold temp_last. simpl. auto.
+ intuition.
+ auto.
+ unfold temp_last. simpl. auto.
constructor.
Qed.
Lemma transitions_preserve_wf:
- forall mu sigma tau mu' sigma' tau',
- transitions mu sigma tau mu' sigma' tau' ->
- state_wf mu sigma tau -> state_wf mu' sigma' tau'.
+ forall st st', transitions st st' -> state_wf st -> state_wf st'.
Proof.
induction 1; intros; eauto.
eapply transition_preserves_wf; eauto.
Qed.
-(* Properties of exec_ *)
+(** ** Transitions preserve semantics *)
+
+(** We define the semantics of states as follows.
+ For a triple [mu, sigma, tau], we perform the moves [tau] in
+ reverse sequential order, then the moves [mu ++ sigma] in parallel. *)
+
+Definition statemove (st: state) (e: env) :=
+ match st with
+ | State mu sigma tau => exec_par (mu ++ sigma) (exec_seq_rev tau e)
+ end.
+
+(** In preparation to showing that transitions preserve semantics,
+ we prove various properties of the parallel and sequential interpretations
+ of moves. *)
Lemma exec_par_outside:
forall m e r, ~In r (dests m) -> exec_par m e r = e r.
@@ -609,12 +672,10 @@ Proof.
intros. rewrite update_o. apply B. tauto. intuition.
Qed.
-(* Semantics of triples (mu, sigma, tau) *)
-
-Definition statemove (mu sigma tau: moves) (e: env) :=
- exec_par (mu ++ sigma) (exec_seq_rev tau e).
-
-(* Equivalence over non-temp regs *)
+(** [env_equiv] is an equivalence relation between environments
+ capturing the fact that two environments assign the same values to
+ non-temporary registers, but can disagree on the values of temporary
+ registers. *)
Definition env_equiv (e1 e2: env) : Prop :=
forall r, is_not_temp r -> e1 r = e2 r.
@@ -657,15 +718,15 @@ Proof.
apply IHm; auto.
Qed.
-(* Preservation of semantics by transformations. *)
+(** The proof that transitions preserve semantics (up to the values of
+ temporary registers) follows. *)
Lemma transition_preserves_semantics:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2 e,
- transition mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- state_wf mu1 sigma1 tau1 ->
- env_equiv (statemove mu2 sigma2 tau2 e) (statemove mu1 sigma1 tau1 e).
+ forall st st' e,
+ transition st st' -> state_wf st ->
+ env_equiv (statemove st' e) (statemove st e).
Proof.
- induction 1; intros [A [B [C D]]].
+ induction 1; intro WF; inversion WF as [mu0 sigma0 tau0 A B C D]; subst; simpl.
(* nop *)
apply env_equiv_refl'. unfold statemove.
@@ -728,134 +789,133 @@ Proof.
Qed.
Lemma transitions_preserve_semantics:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2 e,
- transitions mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- state_wf mu1 sigma1 tau1 ->
- env_equiv (statemove mu2 sigma2 tau2 e) (statemove mu1 sigma1 tau1 e).
+ forall st st' e,
+ transitions st st' -> state_wf st ->
+ env_equiv (statemove st' e) (statemove st e).
Proof.
induction 1; intros.
- apply env_equiv_refl.
eapply transition_preserves_semantics; eauto.
- apply env_equiv_trans with (statemove mu2 sigma2 tau2 e).
- apply IHtransitions2. eapply transitions_preserve_wf; eauto.
- apply IHtransitions1. auto.
+ apply env_equiv_refl.
+ apply env_equiv_trans with (statemove y e); auto.
+ apply IHclos_refl_trans2. eapply transitions_preserve_wf; eauto.
Qed.
Lemma state_wf_start:
forall mu,
move_no_temp mu ->
is_mill mu ->
- state_wf mu nil nil.
+ state_wf (State mu nil nil).
Proof.
- split. rewrite <- app_nil_end. auto.
- split. auto.
- split. red. simpl. auto.
+ intros. constructor. rewrite <- app_nil_end. auto.
+ auto.
+ red. simpl. auto.
constructor.
Qed.
+(** The main correctness result in this section is the following:
+ if we can transition repeatedly from an initial state [mu, nil, nil]
+ to a final state [nil, nil, tau], then the sequential execution
+ of the moves [rev tau] is semantically equivalent to the parallel
+ execution of the moves [mu]. *)
+
Theorem transitions_correctness:
forall mu tau,
move_no_temp mu ->
is_mill mu ->
- transitions mu nil nil nil nil tau ->
+ transitions (State mu nil nil) (State nil nil tau) ->
forall e, env_equiv (exec_seq (List.rev tau) e) (exec_par mu e).
Proof.
intros.
- generalize (transitions_preserve_semantics _ _ _ _ _ _ e H1
+ generalize (transitions_preserve_semantics _ _ e H1
(state_wf_start _ H H0)).
unfold statemove. simpl. rewrite <- app_nil_end.
rewrite exec_seq_exec_seq_rev. auto.
Qed.
-(* Determinisation of the transition relation *)
+(** * Determinisation of the transition relation *)
+
+(** We now define a deterministic variant [dtransition] of the
+ transition relation [transition]. [dtransition] is deterministic
+ in the sense that at most one transition applies to a given state. *)
-Inductive dtransition: moves -> moves -> moves
- -> moves -> moves -> moves -> Prop :=
+Inductive dtransition: state -> state -> Prop :=
| dtr_nop: forall r mu tau,
- dtransition ((r, r) :: mu) nil tau
- mu nil tau
+ dtransition (State ((r, r) :: mu) nil tau)
+ (State mu nil tau)
| dtr_start: forall s d mu tau,
s <> d ->
- dtransition ((s, d) :: mu) nil tau
- mu ((s, d) :: nil) tau
+ dtransition (State ((s, d) :: mu) nil tau)
+ (State mu ((s, d) :: nil) tau)
| dtr_push: forall mu1 d r mu2 s sigma tau,
no_read mu1 d ->
- dtransition (mu1 ++ (d, r) :: mu2) ((s, d) :: sigma) tau
- (mu1 ++ mu2) ((d, r) :: (s, d) :: sigma) tau
+ dtransition (State (mu1 ++ (d, r) :: mu2) ((s, d) :: sigma) tau)
+ (State (mu1 ++ mu2) ((d, r) :: (s, d) :: sigma) tau)
| dtr_loop_pop: forall mu s r0 d sigma tau,
no_read mu r0 ->
- dtransition mu ((s, r0) :: sigma ++ (r0, d) :: nil) tau
- mu (sigma ++ (temp r0, d) :: nil) ((s, r0) :: (r0, temp r0) :: tau)
+ dtransition (State mu ((s, r0) :: sigma ++ (r0, d) :: nil) tau)
+ (State mu (sigma ++ (temp r0, d) :: nil) ((s, r0) :: (r0, temp r0) :: tau))
| dtr_pop: forall mu s0 d0 s1 d1 sigma tau,
no_read mu d1 -> d1 <> s0 ->
- dtransition mu ((s1, d1) :: sigma ++ (s0, d0) :: nil) tau
- mu (sigma ++ (s0, d0) :: nil) ((s1, d1) :: tau)
+ dtransition (State mu ((s1, d1) :: sigma ++ (s0, d0) :: nil) tau)
+ (State mu (sigma ++ (s0, d0) :: nil) ((s1, d1) :: tau))
| dtr_last: forall mu s d tau,
no_read mu d ->
- dtransition mu ((s, d) :: nil) tau
- mu nil ((s, d) :: tau).
+ dtransition (State mu ((s, d) :: nil) tau)
+ (State mu nil ((s, d) :: tau)).
-Inductive dtransitions: moves -> moves -> moves
- -> moves -> moves -> moves -> Prop :=
- | dtr_refl:
- forall mu sigma tau,
- dtransitions mu sigma tau mu sigma tau
- | dtr_one:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2,
- dtransition mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- dtransitions mu1 sigma1 tau1 mu2 sigma2 tau2
- | dtr_trans:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2 mu3 sigma3 tau3,
- dtransitions mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- dtransitions mu2 sigma2 tau2 mu3 sigma3 tau3 ->
- dtransitions mu1 sigma1 tau1 mu3 sigma3 tau3.
+Definition dtransitions: state -> state -> Prop :=
+ clos_refl_trans state dtransition.
+
+(** Every deterministic transition corresponds to a sequence of
+ non-deterministic transitions. *)
Lemma transition_determ:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2,
- dtransition mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- state_wf mu1 sigma1 tau1 ->
- transitions mu1 sigma1 tau1 mu2 sigma2 tau2.
-Proof.
- induction 1; intro.
- apply tr_one. exact (tr_nop nil r mu nil tau).
- apply tr_one. exact (tr_start nil s d mu tau).
- apply tr_one. apply tr_push.
- eapply tr_trans.
- apply tr_one.
+ forall st st',
+ dtransition st st' ->
+ state_wf st ->
+ transitions st st'.
+Proof.
+ induction 1; intro; unfold transitions.
+ apply rt_step. exact (tr_nop nil r mu nil tau).
+ apply rt_step. exact (tr_start nil s d mu tau).
+ apply rt_step. apply tr_push.
+ eapply rt_trans.
+ apply rt_step.
change ((s, r0) :: sigma ++ (r0, d) :: nil)
with (((s, r0) :: sigma) ++ (r0, d) :: nil).
apply tr_loop.
- apply tr_one. simpl. apply tr_pop. auto.
- destruct H0 as [A [B [C D]]].
- generalize C.
+ apply rt_step. simpl. apply tr_pop. auto.
+ inv H0. generalize H6.
change ((s, r0) :: sigma ++ (r0, d) :: nil)
with (((s, r0) :: sigma) ++ (r0, d) :: nil).
unfold temp_last; rewrite List.rev_unit. intros [E F].
elim (F s r0). unfold is_not_temp. auto.
rewrite <- List.In_rev. apply in_eq.
- apply tr_one. apply tr_pop. auto. auto.
- apply tr_one. apply tr_last. auto.
+ apply rt_step. apply tr_pop. auto. auto.
+ apply rt_step. apply tr_last. auto.
Qed.
Lemma transitions_determ:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2,
- dtransitions mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- state_wf mu1 sigma1 tau1 ->
- transitions mu1 sigma1 tau1 mu2 sigma2 tau2.
+ forall st st',
+ dtransitions st st' ->
+ state_wf st ->
+ transitions st st'.
Proof.
- induction 1; intros.
- apply tr_refl.
+ unfold transitions; induction 1; intros.
eapply transition_determ; eauto.
- eapply tr_trans.
- apply IHdtransitions1. auto.
- apply IHdtransitions2. eapply transitions_preserve_wf; eauto.
+ apply rt_refl.
+ apply rt_trans with y. auto.
+ apply IHclos_refl_trans2.
+ apply transitions_preserve_wf with x; auto. red; auto.
Qed.
+(** The semantic correctness of deterministic transitions follows. *)
+
Theorem dtransitions_correctness:
forall mu tau,
move_no_temp mu ->
is_mill mu ->
- dtransitions mu nil nil nil nil tau ->
+ dtransitions (State mu nil nil) (State nil nil tau) ->
forall e, env_equiv (exec_seq (List.rev tau) e) (exec_par mu e).
Proof.
intros.
@@ -863,7 +923,11 @@ Proof.
apply transitions_determ. auto. apply state_wf_start; auto.
Qed.
-(* Transition function *)
+(** * The compilation function *)
+
+(** We now define a function that takes a well-formed parallel move [mu]
+ and returns a sequence of elementary moves [tau] that is semantically
+ equivalent. We start by defining a number of auxiliary functions. *)
Function split_move (m: moves) (r: reg) {struct m} : option (moves * reg * moves) :=
match m with
@@ -893,8 +957,6 @@ Function replace_last_source (r: reg) (m: moves) {struct m} : moves :=
| s_d :: tl => s_d :: replace_last_source r tl
end.
-Inductive state : Set := State: moves -> moves -> moves -> state.
-
Definition final_state (st: state) : bool :=
match st with
| State nil nil _ => true
@@ -923,7 +985,7 @@ Function parmove_step (st: state) : state :=
end
end.
-(* Correctness properties of these functions *)
+(** Here are the main correctness properties of these functions. *)
Lemma split_move_charact:
forall m r,
@@ -966,54 +1028,50 @@ Proof.
Qed.
Lemma parmove_step_compatible:
- forall mu sigma tau mu' sigma' tau',
- final_state (State mu sigma tau) = false ->
- parmove_step (State mu sigma tau) = State mu' sigma' tau' ->
- dtransition mu sigma tau mu' sigma' tau'.
+ forall st,
+ final_state st = false ->
+ dtransition st (parmove_step st).
Proof.
- intros until tau'. intro NOTFINAL.
- unfold parmove_step.
+ intros st NOTFINAL. destruct st as [mu sigma tau]. unfold parmove_step.
case_eq mu; [intros MEQ | intros [ms md] mtl MEQ].
case_eq sigma; [intros SEQ | intros [ss sd] stl SEQ].
- subst mu sigma. discriminate.
+ subst mu sigma. simpl in NOTFINAL. discriminate.
simpl.
case_eq stl; [intros STLEQ | intros xx1 xx2 STLEQ].
- intro R; inversion R; clear R; subst.
apply dtr_last. red; simpl; auto.
elim (@exists_last _ stl). 2:congruence. intros sigma1 [[ss1 sd1] SEQ2].
rewrite <- STLEQ. clear STLEQ xx1 xx2.
generalize (is_last_source_charact sd ss1 sd1 sigma1).
rewrite SEQ2. destruct (is_last_source sd (sigma1 ++ (ss1, sd1) :: nil)).
- intro. subst ss1. intro R; inversion R; clear R; subst.
+ intro. subst ss1.
rewrite replace_last_source_charact. apply dtr_loop_pop.
red; simpl; auto.
- intro. intro R; inversion R; clear R; subst.
- apply dtr_pop. red; simpl; auto. auto.
+ intro. apply dtr_pop. red; simpl; auto. auto.
case_eq sigma; [intros SEQ | intros [ss sd] stl SEQ].
- destruct (reg_eq ms md); intro R; inversion R; clear R; subst.
- apply dtr_nop.
+ destruct (reg_eq ms md).
+ subst. apply dtr_nop.
apply dtr_start. auto.
generalize (split_move_charact ((ms, md) :: mtl) sd).
case (split_move ((ms, md) :: mtl) sd); [intros [[before r] after] | idtac].
- intros [MEQ2 NOREAD]. intro R; inversion R; clear R; subst.
+ intros [MEQ2 NOREAD].
rewrite MEQ2. apply dtr_push. auto.
intro NOREAD.
case_eq stl; [intros STLEQ | intros xx1 xx2 STLEQ].
- intro R; inversion R; clear R; subst.
apply dtr_last. auto.
elim (@exists_last _ stl). 2:congruence. intros sigma1 [[ss1 sd1] SEQ2].
rewrite <- STLEQ. clear STLEQ xx1 xx2.
generalize (is_last_source_charact sd ss1 sd1 sigma1).
rewrite SEQ2. destruct (is_last_source sd (sigma1 ++ (ss1, sd1) :: nil)).
- intro. subst ss1. intro R; inversion R; clear R; subst.
+ intro. subst ss1.
rewrite replace_last_source_charact. apply dtr_loop_pop. auto.
- intro. intro R; inversion R; clear R; subst.
- apply dtr_pop. auto. auto.
+ intro. apply dtr_pop. auto. auto.
Qed.
-(* Decreasing measure over states *)
+(** The compilation function is obtained by iterating the [parmov_step]
+ function. To show that this iteration always terminates, we introduce
+ the following measure over states. *)
Open Scope nat_scope.
@@ -1023,9 +1081,8 @@ Definition measure (st: state) : nat :=
end.
Lemma measure_decreasing_1:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2,
- dtransition mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- measure (State mu2 sigma2 tau2) < measure (State mu1 sigma1 tau1).
+ forall st st',
+ dtransition st st' -> measure st' < measure st.
Proof.
induction 1; repeat (simpl; rewrite List.app_length); simpl; omega.
Qed.
@@ -1035,13 +1092,10 @@ Lemma measure_decreasing_2:
final_state st = false ->
measure (parmove_step st) < measure st.
Proof.
- intros. destruct st as [mu sigma tau].
- case_eq (parmove_step (State mu sigma tau)). intros mu' sigma' tau' EQ.
- apply measure_decreasing_1.
- apply parmove_step_compatible; auto.
+ intros. apply measure_decreasing_1. apply parmove_step_compatible; auto.
Qed.
-(* Compilation function for parallel moves *)
+(** Compilation function for parallel moves. *)
Function parmove_aux (st: state) {measure measure st} : moves :=
if final_state st
@@ -1052,26 +1106,22 @@ Proof.
Qed.
Lemma parmove_aux_transitions:
- forall mu sigma tau,
- dtransitions mu sigma tau nil nil (parmove_aux (State mu sigma tau)).
+ forall st,
+ dtransitions st (State nil nil (parmove_aux st)).
Proof.
- assert (forall st,
- match st with State mu sigma tau =>
- dtransitions mu sigma tau nil nil (parmove_aux st)
- end).
- intro st. functional induction (parmove_aux st).
- destruct _x; destruct _x0; simpl in e; discriminate || apply dtr_refl.
- case_eq (parmove_step st). intros mu' sigma' tau' PSTEP.
- destruct st as [mu sigma tau].
- eapply dtr_trans. apply dtr_one. apply parmove_step_compatible; eauto.
- rewrite PSTEP in IHm. auto.
-
- intros. apply (H (State mu sigma tau)).
+ unfold dtransitions. intro st. functional induction (parmove_aux st).
+ destruct _x; destruct _x0; simpl in e; discriminate || apply rt_refl.
+ eapply rt_trans. apply rt_step. apply parmove_step_compatible; eauto.
+ auto.
Qed.
Definition parmove (mu: moves) : moves :=
List.rev (parmove_aux (State mu nil nil)).
+(** This is the main correctness theorem: the sequence of elementary
+ moves [parmove mu] is semantically equivalent to the parallel move
+ [mu] if the latter is well-formed. *)
+
Theorem parmove_correctness:
forall mu,
move_no_temp mu -> is_mill mu ->
@@ -1082,6 +1132,10 @@ Proof.
apply parmove_aux_transitions.
Qed.
+(** Here is an alternate formulation of [parmove], where the
+ parallel move problem is given as two separate lists of sources
+ and destinations. *)
+
Definition parmove2 (sl dl: list reg) : moves :=
parmove (List.combine sl dl).
@@ -1111,7 +1165,13 @@ Proof.
intros. transitivity (e1 r); auto.
Qed.
-(* Additional properties on the generated sequence of moves. *)
+(** * Additional syntactic properties *)
+
+(** We now show an additional property of the sequence of moves
+ generated by [parmove mu]: any such move [s -> d] is either
+ already present in [mu], or of the form [temp s -> d] or [s -> temp s]
+ for some [s -> d] in [mu]. This syntactic property is useful
+ to show that [parmove] preserves typing, for instance. *)
Section PROPERTIES.
@@ -1145,36 +1205,23 @@ Qed.
Hint Rewrite wf_moves_cons wf_moves_append: pmov.
-Definition wf_state (mu sigma tau: moves) : Prop :=
- wf_moves mu /\ wf_moves sigma /\ wf_moves tau.
+Inductive wf_state: state -> Prop :=
+ | wf_state_intro: forall mu sigma tau,
+ wf_moves mu -> wf_moves sigma -> wf_moves tau ->
+ wf_state (State mu sigma tau).
Lemma dtransition_preserves_wf_state:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2,
- dtransition mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- wf_state mu1 sigma1 tau1 -> wf_state mu2 sigma2 tau2.
+ forall st st',
+ dtransition st st' -> wf_state st -> wf_state st'.
Proof.
- induction 1; intros [A [B C]]; unfold wf_state;
- autorewrite with pmov in A; autorewrite with pmov in B;
- autorewrite with pmov in C; autorewrite with pmov.
-
- tauto.
-
- tauto.
-
- tauto.
-
- intuition. apply wf_move_temp_left; auto.
+ induction 1; intro WF; inv WF; constructor; autorewrite with pmov in *; intuition.
+ apply wf_move_temp_left; auto.
eapply wf_move_temp_right; eauto.
-
- intuition.
-
- intuition.
Qed.
Lemma dtransitions_preserve_wf_state:
- forall mu1 sigma1 tau1 mu2 sigma2 tau2,
- dtransitions mu1 sigma1 tau1 mu2 sigma2 tau2 ->
- wf_state mu1 sigma1 tau1 -> wf_state mu2 sigma2 tau2.
+ forall st st',
+ dtransitions st st' -> wf_state st -> wf_state st'.
Proof.
induction 1; intros; eauto.
eapply dtransition_preserves_wf_state; eauto.
@@ -1186,14 +1233,14 @@ Lemma parmove_wf_moves:
forall mu, wf_moves mu (parmove mu).
Proof.
intros.
- assert (wf_state mu mu nil nil).
- split. red; intros. apply wf_move_same. auto.
- split. red; simpl; tauto. red; simpl; tauto.
+ assert (wf_state mu (State mu nil nil)).
+ constructor. red; intros. apply wf_move_same. auto.
+ red; simpl; tauto. red; simpl; tauto.
generalize (dtransitions_preserve_wf_state mu
- _ _ _ _ _ _
- (parmove_aux_transitions mu nil nil) H).
- intros [A [B C]].
- unfold parmove. red; intros. apply C.
+ _ _
+ (parmove_aux_transitions (State mu nil nil)) H).
+ intro WFS. inv WFS.
+ unfold parmove. red; intros. apply H5.
rewrite List.In_rev. auto.
Qed.
diff --git a/runtime/Makefile b/runtime/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..c45c9fb80b65d5e0699c13ee4de2b4fd424c2124
--- /dev/null
+++ b/runtime/Makefile
@@ -0,0 +1,13 @@
+CFLAGS=-arch ppc -O1 -g -Wall
+#CFLAGS=-O1 -g -Wall
+OBJS=stdio.o calloc.o
+LIB=libcompcert.a
+
+$(LIB): $(OBJS)
+ rm -f $(LIB)
+ ar rcs $(LIB) $(OBJS)
+
+stdio.o: stdio.h
+
+clean:
+ rm -f *.o $(LIB)
diff --git a/runtime/calloc.c b/runtime/calloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..2526cebf5cec61c2c204c54fd5a77e97a6e22afb
--- /dev/null
+++ b/runtime/calloc.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+void * compcert_alloc(int sz)
+{
+ void * res = malloc(sz);
+ if (res == NULL) {
+ fprintf(stderr, "Out of memory in compcert_alloc().\n");
+ abort();
+ }
+ return res;
+}
diff --git a/runtime/stdio.c b/runtime/stdio.c
new file mode 100644
index 0000000000000000000000000000000000000000..c1532572c6f4545e88a8d5ba2b0b8eaf07952cf7
--- /dev/null
+++ b/runtime/stdio.c
@@ -0,0 +1,152 @@
+#include <stdarg.h>
+#include <stdlib.h>
+#define _INSIDE_COMPCERT_COMPATIBILITY_LIBRARY
+#include "stdio.h"
+
+static compcert_FILE * compcert_alloc_file(FILE * f)
+{
+ struct compcert_FILE_ * r;
+ r = malloc(sizeof(struct compcert_FILE_));
+ if (r == NULL) return NULL;
+ r->fstr = (void *) f;
+ return r;
+}
+
+compcert_FILE * compcert_stdin;
+compcert_FILE * compcert_stdout;
+compcert_FILE * compcert_stderr;
+
+static __attribute__((constructor)) void compcert_stdio_init(void)
+{
+ compcert_stdin = compcert_alloc_file(stdin);
+ compcert_stdout = compcert_alloc_file(stdout);
+ compcert_stderr = compcert_alloc_file(stderr);
+}
+
+void compcert_clearerr(compcert_FILE * f)
+{
+ clearerr((FILE *)(f->fstr));
+}
+
+int compcert_fclose(compcert_FILE * f)
+{
+ int errcode = fclose((FILE *)(f->fstr));
+ free(f);
+ return errcode;
+}
+
+int compcert_feof(compcert_FILE * f)
+{
+ return feof((FILE *)(f->fstr));
+}
+
+int compcert_ferror(compcert_FILE * f)
+{
+ return ferror((FILE *)(f->fstr));
+}
+
+int compcert_fflush(compcert_FILE * f)
+{
+ return fflush((FILE *)(f->fstr));
+}
+
+int compcert_fgetc(compcert_FILE * f)
+{
+ return fgetc((FILE *)(f->fstr));
+}
+
+char *compcert_fgets(char * s, int n, compcert_FILE * f)
+{
+ return fgets(s, n, (FILE *)(f->fstr));
+}
+
+compcert_FILE *compcert_fopen(const char * p, const char * m)
+{
+ FILE * f = fopen(p, m);
+ if (f == NULL) return NULL;
+ return compcert_alloc_file(f);
+}
+
+int compcert_fprintf(compcert_FILE * f, const char * s, ...)
+{
+ va_list ap;
+ int retcode;
+ va_start(ap, s);
+ retcode = vfprintf((FILE *)(f->fstr), s, ap);
+ va_end(ap);
+ return retcode;
+}
+
+int compcert_fputc(int c, compcert_FILE * f)
+{
+ return fputc(c, (FILE *)(f->fstr));
+}
+
+int compcert_fputs(const char * s, compcert_FILE * f)
+{
+ return fputs(s, (FILE *)(f->fstr));
+}
+
+size_t compcert_fread(void * s, size_t p, size_t q, compcert_FILE * f)
+{
+ return fread(s, p, q, (FILE *)(f->fstr));
+}
+
+compcert_FILE *compcert_freopen(const char * s, const char * m,
+ compcert_FILE * f)
+{
+ FILE * nf = freopen(s, m, (FILE *)(f->fstr));
+ if (nf == NULL) return NULL;
+ f->fstr = nf;
+ return f;
+}
+
+int compcert_fscanf(compcert_FILE * f, const char * s, ...)
+{
+ va_list ap;
+ int retcode;
+ va_start(ap, s);
+ retcode = vfscanf((FILE *)(f->fstr), s, ap);
+ va_end(ap);
+ return retcode;
+}
+
+int compcert_fseek(compcert_FILE * f, long p, int q)
+{
+ return fseek((FILE *)(f->fstr), p, q);
+}
+
+long compcert_ftell(compcert_FILE *f)
+{
+ return ftell((FILE *)(f->fstr));
+}
+
+size_t compcert_fwrite(const void * b, size_t p, size_t q, compcert_FILE * f)
+{
+ return fwrite(b, p, q, (FILE *)(f->fstr));
+}
+
+int compcert_getc(compcert_FILE * f)
+{
+ return getc((FILE *)(f->fstr));
+}
+
+int compcert_putc(int c , compcert_FILE * f)
+{
+ return putc(c, (FILE *)(f->fstr));
+}
+
+void compcert_rewind(compcert_FILE * f)
+{
+ rewind((FILE *)(f->fstr));
+}
+
+int compcert_ungetc(int c, compcert_FILE * f)
+{
+ return ungetc(c, (FILE *)(f->fstr));
+}
+
+int compcert_vfprintf(compcert_FILE * f, const char * s, va_list va)
+{
+ return vfprintf((FILE *)(f->fstr), s, va);
+}
diff --git a/runtime/stdio.h b/runtime/stdio.h
new file mode 100644
index 0000000000000000000000000000000000000000..2442dcb15cb57ec9f51631a5c6e4811a64eb121e
--- /dev/null
+++ b/runtime/stdio.h
@@ -0,0 +1,67 @@
+#ifndef _COMPCERT_STDIO_H
+#define _COMPCERT_STDIO_H
+
+#include "/usr/include/stdio.h"
+
+typedef struct compcert_FILE_ { void * fstr; } compcert_FILE;
+
+extern compcert_FILE * compcert_stdin;
+extern compcert_FILE * compcert_stdout;
+extern compcert_FILE * compcert_stderr;
+extern void compcert_clearerr(compcert_FILE *);
+extern int compcert_fclose(compcert_FILE *);
+extern int compcert_feof(compcert_FILE *);
+extern int compcert_ferror(compcert_FILE *);
+extern int compcert_fflush(compcert_FILE *);
+extern int compcert_fgetc(compcert_FILE *);
+extern char *compcert_fgets(char * , int, compcert_FILE *);
+extern compcert_FILE *compcert_fopen(const char * , const char * );
+extern int compcert_fprintf(compcert_FILE * , const char * , ...);
+extern int compcert_fputc(int, compcert_FILE *);
+extern int compcert_fputs(const char * , compcert_FILE * );
+extern size_t compcert_fread(void * , size_t, size_t, compcert_FILE * );
+extern compcert_FILE *compcert_freopen(const char * , const char * ,
+ compcert_FILE * );
+extern int compcert_fscanf(compcert_FILE * , const char * , ...);
+extern int compcert_fseek(compcert_FILE *, long, int);
+extern long compcert_ftell(compcert_FILE *);
+extern size_t compcert_fwrite(const void * , size_t, size_t, compcert_FILE * );
+extern int compcert_getc(compcert_FILE *);
+extern int compcert_putc(int, compcert_FILE *);
+extern void compcert_rewind(compcert_FILE *);
+extern int compcert_ungetc(int, compcert_FILE *);
+extern int compcert_vfprintf(compcert_FILE *, const char *, va_list);
+
+#ifndef _INSIDE_COMPCERT_COMPATIBILITY_LIBRARY
+#define FILE compcert_FILE
+#undef stdin
+#define stdin compcert_stdin
+#undef stdout
+#define stdout compcert_stdout
+#undef stderr
+#define stderr compcert_stderr
+#define clearerr compcert_clearerr
+#define fclose compcert_fclose
+#define feof compcert_feof
+#define ferror compcert_ferror
+#define fflush compcert_fflush
+#define fgetc compcert_fgetc
+#define fgets compcert_fgets
+#define fopen compcert_fopen
+#define fprintf compcert_fprintf
+#define fputc compcert_fputc
+#define fputs compcert_fputs
+#define fread compcert_fread
+#define freopen compcert_freopen
+#define fscanf compcert_fscanf
+#define fseek compcert_fseek
+#define ftell compcert_ftell
+#define fwrite compcert_fwrite
+#define getc compcert_getc
+#define putc compcert_putc
+#define rewind compcert_rewind
+#define ungetc compcert_ungetc
+#define vfprintf compcert_vfprintf
+#endif
+
+#endif
diff --git a/test/c/Makefile b/test/c/Makefile
index 88969342821085ad6bfe10aa94128c32f11d58a3..3f4ea40ae3374cea92e623d6626c9d1c447a7803 100644
--- a/test/c/Makefile
+++ b/test/c/Makefile
@@ -1,8 +1,7 @@
CCOMP=../../ccomp
-CCOMPFLAGS=-dump-c -I../lib
+CCOMPFLAGS=-stdlib ../../runtime -dclight -dasm
CC=gcc -arch ppc
-
CFLAGS=-O1 -Wall
LIBS=
@@ -20,11 +19,11 @@ all: $(PROGS:%=%.compcert)
all_gcc: $(PROGS:%=%.gcc)
-%.compcert: %.s
- $(CC) $(CFLAGS) -o $*.compcert $*.s ../lib/libcompcert.a $(LIBS)
+%.compcert: %.c $(CCOMP)
+ $(CCOMP) $(CCOMPFLAGS) -o $*.compcert $*.c $(LIBS)
%.s: %.c ../../ccomp
- $(CCOMP) $(CCOMPFLAGS) $*.c
+ $(CCOMP) $(CCOMPFLAGS) -S $*.c
%.gcc: %.c
$(CC) $(CFLAGS) -o $*.gcc $*.c $(LIBS)
diff --git a/test/c/knucleotide.c b/test/c/knucleotide.c
index 955af7f90fea29c6160526c72bfac15cf96e6c82..f74389263681a8abf85031c1412071dd38569d35 100644
--- a/test/c/knucleotide.c
+++ b/test/c/knucleotide.c
@@ -8,11 +8,7 @@
http://cvs.alioth.debian.org/cgi-bin/cvsweb.cgi/shootout/bench/Include/?cvsroot=shootout
*/
-#ifdef __COMPCERT__
-#include <compcert_stdio.h>
-#else
#include <stdio.h>
-#endif
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
diff --git a/test/c/mandelbrot.c b/test/c/mandelbrot.c
index f4c0db1bcaf9c839cd1ab0c150647b5186f83d8e..93aa8acb5191e5470526a8367ff75684a7c51a47 100644
--- a/test/c/mandelbrot.c
+++ b/test/c/mandelbrot.c
@@ -10,11 +10,7 @@
compile flags: -O3 -ffast-math -march=pentium4 -funroll-loops
*/
-#ifdef __COMPCERT__
-#include <compcert_stdio.h>
-#else
#include <stdio.h>
-#endif
#include <stdlib.h>
int main (int argc, char **argv)
diff --git a/test/cminor/Makefile b/test/cminor/Makefile
index 29ebf699bdd3e45590f681724a9c3d9667b8d96b..9d2dfdb9ff533d5ee9395b4e7a90584b65dab53c 100644
--- a/test/cminor/Makefile
+++ b/test/cminor/Makefile
@@ -1,4 +1,5 @@
CCOMP=../../ccomp
+FLAGS=-S
CPP=cpp -P
CC=gcc
CFLAGS=-arch ppc -g
@@ -69,6 +70,11 @@ marksweep: marksweep.o maingc.o marksweepcheck.o
clean::
rm -f stopcopy
+switchtbl: switchtbl.o mainswitchtbl.o
+ $(CC) $(CFLAGS) -o switchtbl switchtbl.o mainswitchtbl.o
+clean::
+ rm -f switchtbl
+
.SUFFIXES:
.SUFFIXES: .cmp .cm .s .o .c .S
diff --git a/test/cminor/sha1.cmp b/test/cminor/sha1.cmp
index ca245443fb9f4cb9e98fe7fa2ee460d6b1c59b0d..31c4b1786d75828241bb705c8bc1cfc3d7b1d501 100644
--- a/test/cminor/sha1.cmp
+++ b/test/cminor/sha1.cmp
@@ -54,7 +54,7 @@ extern "memset" : int -> int -> int -> void
"SHA1_transform"(ctx) : int -> void
{
- stack 320
+ stack 320;
var i, p, a, b, c, d, e, t;
/* Convert buffer data to 16 big-endian integers */
diff --git a/test/cminor/switchtbl.cm b/test/cminor/switchtbl.cm
new file mode 100644
index 0000000000000000000000000000000000000000..07bda7ed3440bb66aadfdc564f01addb3af51bd6
--- /dev/null
+++ b/test/cminor/switchtbl.cm
@@ -0,0 +1,16 @@
+"f"(x): int -> int
+{
+ match (x) {
+ case 0: return 00;
+ case 1: return 11;
+ case 2: return 22;
+ case 3: return 33;
+ case 4: return 44;
+ case 5: return 55;
+ case 6: return 66;
+ case 7: return 77;
+ case 8: return 88;
+ case 9: return 99;
+}
+}
+
diff --git a/test/harness/mainlists.c b/test/harness/mainlists.c
index ef11f6ef8ea244f54a3788b942e7d27a1bae9231..281b919f3c7c0319457b5b1ff60a192b5cc6ecc1 100644
--- a/test/harness/mainlists.c
+++ b/test/harness/mainlists.c
@@ -2,11 +2,6 @@
#include <stddef.h>
#include <stdlib.h>
-void * compcert_alloc(int sz)
-{
- return malloc(sz);
-}
-
struct cons { int hd; struct cons * tl; };
typedef struct cons * list;
diff --git a/test/harness/mainswitchtbl.c b/test/harness/mainswitchtbl.c
new file mode 100644
index 0000000000000000000000000000000000000000..24ba17e7c9fe9a5ab965219f127d1c7028738c32
--- /dev/null
+++ b/test/harness/mainswitchtbl.c
@@ -0,0 +1,11 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+extern int f(int);
+
+int main(int argc, char ** argv)
+{
+ int i;
+ for (i = 0; i < 10; i++) printf("%2d -> %2d\n", i, f(i));
+ return 0;
+}