The categorical abstract machine
Proc. of a conference on Functional programming languages and computer architecture
Lambda lifting: transforming programs to recursive equations
Proc. of a conference on Functional programming languages and computer architecture
ORBIT: an optimizing compiler for scheme
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Elimination algorithms for data flow analysis
ACM Computing Surveys (CSUR)
The design and evaluation of a high performance Smalltalk system
The design and evaluation of a high performance Smalltalk system
Garbage collection can be faster than stack allocation
Information Processing Letters
Safety consideration for storage allocation optimizations
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Minimizing register usage penalty at procedure calls
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Implementation strategies for continuations
LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Coloring heuristics for register allocation
PLDI '89 Proceedings of the ACM SIGPLAN 1989 Conference on Programming language design and implementation
Realistic compilation by program transformation (detailed summary)
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Continuation-passing, closure-passing style
POPL '89 Proceedings of the 16th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
The definition of Standard ML
Efficient stack allocation for tail-recursive languages
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Representing control in the presence of first-class continuations
PLDI '90 Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation
Globalization and live variables
PEPM '91 Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Control-flow analysis of higher-order languages of taming lambda
Control-flow analysis of higher-order languages of taming lambda
Compiling with continuations
The essence of compiling with continuations
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Space-efficient closure representations
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Callee-save registers in continuation-passing style
Lisp and Symbolic Computation
Cache write policies and performance
ISCA '93 Proceedings of the 20th annual international symposium on computer architecture
Memory subsystem performance of programs using copying garbage collection
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Selective and lightweight closure conversion
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A type-based compiler for standard ML
PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
Compiling standard ML for efficient execution on modern machines
Compiling standard ML for efficient execution on modern machines
POPL '96 Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Flexible representation analysis
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
Generational stack collection and profile-driven pretenuring
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Proper tail recursion and space efficiency
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Advanced compiler design and implementation
Advanced compiler design and implementation
Stack-Based Typed Assembly Language
TIC '98 Proceedings of the Second International Workshop on Types in Compilation
A Portable and Optimizing Back End for the SML/NJ Compiler
CC '94 Proceedings of the 5th International Conference on Compiler Construction
Compiling a functional language
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
The dream of a lifetime: A lazy variable extent mechanism
LFP '80 Proceedings of the 1980 ACM conference on LISP and functional programming
Register allocation & spilling via graph coloring
SIGPLAN '82 Proceedings of the 1982 SIGPLAN symposium on Compiler construction
Rabbit: A Compiler for Scheme
Orbit: an optimizing compiler for scheme
Orbit: an optimizing compiler for scheme
Type-preserving garbage collectors
POPL '01 Proceedings of the 28th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
BIT: A Very Compact Scheme System for Microcontrollers
Higher-Order and Symbolic Computation
Status report: the manticore project
ML '07 Proceedings of the 2007 workshop on Workshop on ML
Flattening tuples in an SSA intermediate representation
Higher-Order and Symbolic Computation
| Hi-index | 0.01 |
Modern compilers often implement function calls (or returns) in two steps: first, a “closure” environment is properly installed to provide access for free variables in the target program fragment; second, the control is transferred to the target by a “jump with arguments (for results).” Closure conversion—which decides where and how to represent closures at runtime—is a crucial step in the compilation of functional languages. This paper presents a new algorithm that exploits the use of compile-time control and data-flow information to optimize funtion calls. By extensive closure sharing and allocation by 36% and memory fetches for local and global variables by 43%; and improves the already efficient code generated by an earlier version of the Standard ML of New Jersey compiler by about 17% on a DECstation 5000. Moreover, unlike most other approaches, our new closure-allocation scheme the strong safe-for-space-complexity rule, thus achieving good asymptotic space usage.