ORBIT: an optimizing compiler for scheme
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Realistic compilation by program transformation (detailed summary)
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Properties of data flow frameworks: a unified model
Acta Informatica
Collecting interpretations of expressions
ACM Transactions on Programming Languages and Systems (TOPLAS)
Control-flow analysis of higher-order languages of taming lambda
Control-flow analysis of higher-order languages of taming lambda
For a better support of static data flow
Proceedings of the 5th ACM conference on Functional programming languages and computer architecture
Compiling with continuations
Improving binding times without explicit CPS-conversion
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
Reasoning about programs in continuation-passing style.
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
The essence of compiling with continuations
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Continuation passing transformation and abstract interpretation
Proceedings of the First Imperial College Department of Computing Workshop on Theory and formal methods 1993
POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Rabbit: A Compiler for Scheme
The semantics of future and its use in program optimization
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A unified treatment of flow analysis in higher-order languages
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A correspondence between continuation passing style and static single assignment form
IR '95 Papers from the 1995 ACM SIGPLAN workshop on Intermediate representations
Lightweight closure conversion
ACM Transactions on Programming Languages and Systems (TOPLAS)
Introducing a CPS style optimizer into an existing compiler
ACM SIGPLAN Notices
Syntactic accidents in program analysis: on the impact of the CPS transformation
ICFP '00 Proceedings of the fifth ACM SIGPLAN international conference on Functional programming
CPS Translations and Applications: The Cube and Beyond
Higher-Order and Symbolic Computation
Optimizing Nested Loops Using Local CPS Conversion
Higher-Order and Symbolic Computation
Secure Information Flow via Linear Continuations
Higher-Order and Symbolic Computation
Secure Information Flow and CPS
ESOP '01 Proceedings of the 10th European Symposium on Programming Languages and Systems
A computational formalization for partial evaluation
Mathematical Structures in Computer Science
Syntactic accidents in program analysis: on the impact of the CPS transformation
Journal of Functional Programming
CPS transformation of flow information
Journal of Functional Programming
Higher-order control-flow analysis in retrospect: lessons learned, lessons abandoned
ACM SIGPLAN Notices - Best of PLDI 1979-1999
The essence of compiling with continuations
ACM SIGPLAN Notices - Best of PLDI 1979-1999
A Calculational Approach to Control-Flow Analysis by Abstract Interpretation
SAS '08 Proceedings of the 15th international symposium on Static Analysis
Control-flow analysis of function calls and returns by abstract interpretation
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Control-flow analysis of function calls and returns by abstract interpretation
Information and Computation
Control-flow analysis of functional programs
ACM Computing Surveys (CSUR)
| Hi-index | 0.00 |
The widespread use of the continuation-passing style (CPS) transformation in compilers, optimizers, abstract interpreters, and partial evaluators reflects a common belief that the transformation has a positive effect on the analysis of programs. Investigations by Nielson [13] and Burn/Filho [5,6] support, to some degree, this belief with theoretical results. However, they do not pinpoint the source of increased abstract information and do not explain the observation of many people that continuation-passing confuses some conventional data flow analyses.To study the impact of the CPS transformation on program analysis, we derive three canonical data flow analyzers for the core of an applicative higher-order programming language. The first analyzer is based on a direct semantics of the language, the second on a continuation-semantics of the language, and the last on the direct semantics of CPS terms. All analyzers compute the control flow graph of the source program and hence our results apply to a large class of data flow analyses. A comparison of the information gathered by our analyzers establishes the following points:1. The results of a direct analysis of a source program are incomparable to the results of an analysis of the equivalent CPS program. In other words, the translation of the source program to a CPS version may increase or decrease static information. The gain of information occurs in non-distributive analyses and is solely due to the duplication of the analysis of the continuation. The loss of information is due to the confusion of distinct procedure returns.2. The analyzer based on the continuation semantics produces more accurate results than both direct analyzers, but again only in non-distributive analyses due to the duplication of continuations along every execution path. However, when the analyzer explicitly accounts for looping constructs, the results of the semantic-CPS analysis are no longer computable.In view of these results, we argue that, in practice, a direct data flow analysis that relies on some amount of duplication would be as satisfactory as a CPS analysis.