Exploiting reachability and cardinality in higher-order flow analysis

Authors:
Matthew Might;Olin Shivers
Affiliations:
Diagis, llc, atlanta, ga, usa (e-mail: matt@diagis.com);Northeastern university, boston, ma, usa (e-mail: shivers@ccs.neu.edu)
Venue:
Journal of Functional Programming
Year:
2008

Citing 17
Cited 8

Control flow analysis in scheme

PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Analysis of pointers and structures

PLDI '90 Proceedings of the ACM SIGPLAN 1990 conference on Programming language design and implementation
Control-flow analysis of higher-order languages of taming lambda

Control-flow analysis of higher-order languages of taming lambda
Selective and lightweight closure conversion

POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Closure analysis in constraint form

ACM Transactions on Programming Languages and Systems (TOPLAS)
Single and loving it: must-alias analysis for higher-order languages

POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Polymorphic splitting: an effective polyvariant flow analysis

ACM Transactions on Programming Languages and Systems (TOPLAS)
A semantic model of reference counting and its abstraction (detailed summary)

LFP '86 Proceedings of the 1986 ACM conference on LISP and functional programming
Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints

POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Systematic design of program analysis frameworks

POPL '79 Proceedings of the 6th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
The Cartesian Product Algorithm: Simple and Precise Type Inference Of Parametric Polymorphism

ECOOP '95 Proceedings of the 9th European Conference on Object-Oriented Programming
Rabbit: A Compiler for Scheme

Rabbit: A Compiler for Scheme
Environment analysis via ΔCFA

Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Continuations and transducer composition

Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Improving flow analyses via ΓCFA: abstract garbage collection and counting

Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming
Analyzing the environment structure of higher-order languages using frame strings

Theoretical Computer Science
Model checking via ΓCFA

VMCAI'07 Proceedings of the 8th international conference on Verification, model checking, and abstract interpretation

Model-checking higher-order functions

PPDP '09 Proceedings of the 11th ACM SIGPLAN conference on Principles and practice of declarative programming
Abstract interpreters for free

SAS'10 Proceedings of the 17th international conference on Static analysis
Family of abstract interpretations for static analysis of concurrent higher-order programs

SAS'11 Proceedings of the 18th international conference on Static analysis
Shape analysis in the absence of pointers and structure

VMCAI'10 Proceedings of the 11th international conference on Verification, Model Checking, and Abstract Interpretation
Tearing down the multicore barrier for web applications

Proceedings of the 11th annual international conference on Aspect-oriented Software Development Companion
Hash-flow taint analysis of higher-order programs

Proceedings of the 7th Workshop on Programming Languages and Analysis for Security
Binary reachability analysis of higher order functional programs

SAS'12 Proceedings of the 19th international conference on Static Analysis
Model Checking Higher-Order Programs

Journal of the ACM (JACM)

Quantified Score

Hi-index	0.00

Visualization

Abstract

We present two complementary improvements for abstract-interpretation-based flow analysis of higher-order languages: (1) abstract garbage collection and (2) abstract counting. Abstract garbage collection is an analog to its concrete counterpart: the analysis determines when an abstract resource has become unreachable, and then, re-allocates it as fresh. This prevents flow sets from joining during abstract interpretation, which has two immediate effects: (1) the precision of the interpretation increases and (2) its running time often falls. In abstract counting, the analysis tracks how many times an abstract resource has been allocated. A count of one implies that the abstract resource momentarily represents only one concrete resource. This knowledge, in turn, drives environment analysis, expanding the kind (rather than just the degree) of optimization available to the compiler.