Proving the correctness of compiler optimisations based on a global analysis: A study of strictness analysis

Journal of Functional Programming

Volumn 6, Issue 1, 1996, Pages 75-109

  Burn, Geoffrey ^a   Le Métayer, Daniel ^b  

^a IMPERIAL COLLEGE LONDON   (United Kingdom)

^b CAMPUS DE BEAULIEU   (France)

Author keywords

[No Author keywords available]

Indexed keywords

EID: 3042862970     PISSN: 09567968     EISSN: None     Source Type: Journal    
DOI: 10.1017/S0956796800001581     Document Type: Article

References (53)

1. Appel, A. W. (1992) Compiling with Continuations. Cambridge University Press.
2. Benton, P. N. (1992) Strictness Logic and Polymorphic Invariance. In: Nerode, A. and Taitslin, M., editors, Proc. Int. Symposium on Logical Foundations of Computer Science, pp. 33-44. Tver, Russia. Springer-Verlag.
3. Burn, G. L. (1990) Using projection analysis in compiling lazy functional programs. In: Proc. ACM Conference on Lisp and Functional Programming, pp. 227-241. ACM Press.
4. Burn, G. L. (1991a) The Evaluation Transformer Model of reduction and its correctness. In: Abramsky, S. and Maibaum, T. S. E., editors, Proc, TAPSOFT'91, Vol 2, pp. 458-482, Brighton, UK. Springer-Verlag.
5. Burn, G. L. (1991b) Lazy Functional Languages: Abstract Interpretation and Compilation. Research Monographs in Parallel and Distributed Computing. Pitman (in association with MIT Press).
6. Burn, G. L., Hankin, C. L. and Abramsky, S. (1986) Strictness analysis of higher-order functions. Science of Computer Programming, 7(November): 249-278.
7. Cousineau, G., Curien, P.-L. and Mauny, M. (1987) The categorical abstract machine. Science of Computer Programming, 8: 173-202.
8. Cousot, P. and Cousot, R. (1979) Systematic Design of program analysis frameworks. In: Proc. 6th Ann. Symposium on Principles of Programming Languages, pp. 269-282. ACM Press.
9. Cousot, P. and Cousot, R. (1992a) Abstract interpretation and application to logic programs. J. Logic Programming, 13(2-3): 103-179.
10. Cousot, P. and Cousot, R. (1992b) Abstract interpretation frameworks. J. Logic and Computation, 2(4).
11. Danvy, O. and Filinski, A. (1991) Representing Control: a Study of the Cps Transformation. Technical Report TR CIS-91-2, Kansas State University.
12. Danvy, O. and Hatcliff, J. (1993) CPS Transformation after strictness analysis. ACM Letters on Programming Languages and Systems, 1(3): 195-212.
13. Danvy, O. and Hatcliff, J. (1994) A generic account of continuation-passing styles. In: Proc. 21st ACM Sigplan-Sigact Symposium on Principles Of Programming Languages. ACM Press.
14. Dybjer, P. (1985) Using domain algebras to prove the correctness of a compiler. In: Proc. STACS85, pp. 98-108. Springer-Verlag.
15. Finne, S. O. and Burn, G. L. (1993) Assessing the Evaluation Transformer Model of reduction on the spineless G-machine. In: Proc. Conf. Functional Programming and Computer Architecture, pp. 331-340. ACM Press.
16. Fischer, M. J. (1972) Lambda calculus schemata. In: ACM Conf. on Proving Assertions about Programs, pp. 104-109, New Mexico. (ACM Sigplan Notices 7(1).)
17. Fischer, M. J. (1993) Lambda calculus schemata. Lisp and Symbolic Computation, 6(3/4): 259-287.
18. Flanagan, C., Sabry, A., Duba, B. F. and Felleisen, M. (1993) The essence of compiling with continuations. In: ACM Sigplan '93 Conf. on Programming Language Design and Implementation, pp. 237-247, Albuquerque, NM. (ACM Sigplan Notices, 28(6).)
19. Fradet, P. (1988) Compilation des langages fonctionnels par transformation de programmes. PhD thesis, Université de Rennes I.
20. Fradet, P. and Le Métayer, D. (1991) Compilation of functional languages by program transformation. ACM Trans. Programming Languages and Systems, 13(1): 21-51.
21. Gerhart, S. L. (1975) Correctness-preserving program transformations. In: Proc. POPL75, pp. 54-66. ACM Press.
22. Giorgi, J. F. and Le Métayer, D. (1990) Continuation-based parallel implementation of functional programming languages. In: Proc. ACM Conf. on Lisp and Functional Programming, pp. 227-241.
23. Gunter, C. A. (1992) Semantics of Programming Languages: Structures and Techniques. MIT Press.
24. Hunt, L. S. (1991) Abstract Interpretation of Functional Languages: From Theory to Practice. PhD thesis, Department of Computing, Imperial College, University of London.
25. Jensen, T. P. (1992a) Abstract Interpretation in Logical Form. PhD thesis, Imperial College, University of London.
26. Jensen, T. P. (1992b) Disjunctive strictness analysis. In: Proc. 7th Symposium on Logic In Computer Science, pp. 174-185, Santa Cruz, CA. IEEE Press.
27. Kranz, D. A. (1988) Orbit: An Optimising Compiler for Scheme. PhD thesis, Department of Computer Science, Yale University. (Report Number YALEU/DCS/RR-632.)
28. Kranz, D. A., Kelsey, R., Rees, J. A., Hudak, P., Philbin, J. and Adams, N. I. (1986) Orbit: an optimising compiler for Scheme. In: Proc. SIGPLAN '86 Symposium on Compiler Construction, pp. 219-233. ACM Press.
29. Kuo, T.-M. and Mishra, P. (1989) Strictness analysis: a new perspective based on type inference. In: Proc. Conf. on Functional Programming Languages and Computer Architecture, pp. 260-272, London, UK. ACM Press.
30. Lester, D. R. (1987) The G-machine as a representation of stack semantics. In: Kahn, G., editor, Proc. Functional Programming Languages and Computer Architecture Conf., pp. 46-59. Springer-Verlag.
31. Lester, D. R. (1988) Combinator Graph Reduction: A Congruence and its Applications. DPhil thesis, Oxford University. (Also published as Technical Monograph PRG-73.)
32. Leung, A. and Mishra, P. (1991) Reasoning about simple and exhaustive demand in higher-order languages. In: Hughes, J., editor, Proc. Conference on Functional Programming and Computer Architecture, pp. 329-351, Cambridge, MA. Springer-Verlag.
33. Meyer, A. and Wand, M. (1985) Continuation semantics in the typed lambda-calculus. In: Proc. Logics of Programs, pp. 219-224. Springer-Verlag.
34. Morris, F. L. (1973) Advice on structuring compilers and proving them correct. In: Proc. POPL73, pp. 144-152 ACM Press.
35. Mosses, P. D. (1980) A constructive approach to compiler correctness. In: Proc. ICALP80, pp. 449-462. Springer-Verlag.
36. Muylaert Filho, J. and Burn, G. L. (1993) Continuation passing transformation and abstract intrepretation. In: Burn, G. L., Gay, S. J. Ryan, M. D., editors, Theory and Formal Methods 1993: Proceedings of the First Imperial College, Department of Computing, Workshop on Theory and Formal Methods. Workshops in Computer Science. Sussex, UK. Springer-Verlag.
37. Mycroft, A. (1981) Abstract Interpretation and Optimising Transformations for Applicative Programs. PhD thesis, University of Edinburgh, Department of Computer Science. (Also published as CST-15-81.)
38. Nielson, F. (1985) Program transformations in a denotational setting. ACM TOPLAS, 7: 359-379.
39. Nielson, F. (1988) Strictness analysis and denotational abstract interpretation. Inform. and Comput., 76: 29-92.
40. Nielson, F. (1989) Two-level semantics and abstract interpretation. Theoretical Computer Science, 69: 117-242.
41. Nielson, F. and Nielson, H. R. (1992) The tensor product in Wadler's Analysis of Lists. In: Krieg-Brückner, B., editor, Proceedings of ESOP'92, pp. 351-370, Rennes, France. Springer-Verlag.
42. Nielson, H. R. and Nielson, F. (1988) Two-level Semantics and Code Generation. Theoretical Computer Science, 56: 59-133.
43. Peyton Jones, S. L. and Launchbury, J. (1991) Unboxed values as first class citizens in a non-strict functional language. In: Hughes, J., editor, Proc. Conference on Functional Programming and Computer Architecture, pp. 636-666, Cambridge, MA. Springer-Verlag.
44. Plotkin, G. D. (1975) Call-by-name, Call-by-value and the λ-calculus. Theoretical Computer Science, 1: 125-159.
45. Reynolds, J. C. (1974) On the relation between direct and continuation semantics. In: Proc. 2nd Colloquium on Automata, Languages and Programming, pp. 141-156. Springer-Verlag.
46. Sabry, A. and Felleisen, M. (1992) Reasoning about Programs in Continuation-Passing Style. Technical Report TR 92-180, Rice University.
47. Sabry, A. and Felleisen, M. (1993) Reasoning about programs in continuation-passing style. Lisp and Symbolic Computation, 6(3/4).
48. Schmidt, D. A. (1980) State transition machines for lambda-calculus expressions. In: Proc. Semantics-Directed Compiler Generation Workshop, pp. 415-440. Springer-Verlag.
49. Steele Jr., G. L. (1978) Rabbit: A Compiler for Scheme. Technical report, AI Tech. Rep. 474. MIT, Cambridge, MA.
50. Thatcher, J. W., Wagner, E. G. and Wright, J. B. (1981) More advice on structuring compilers and proving them correct. Theoretical Computer Science, 15: 223-249.
51. Wadler, P. and Hughes, R. J. M. (1987) Projections for strictness analysis. In: Kahn, G., editor, Proc. Functional Programming Languages and Computer Architecture Conf., pp. 385-407. Springer-Verlag.
52. Wadler, P. L. (1987) Strictness analysis on non-flat domains (by abstract interpretation over finite domains). In: Abramsky, S. and Hankin, C. L., editors, Abstract Interpretation of Declarative Languages, pp. 266-275. Ellis Horwood.
53. Wand, M. (1982) Deriving target code as a representation of continuation semantics. ACM Trans. Programming Languages and Systems, 4(3): 496-517.