A Graph-Free Approach to Data-Flow Analysis

  title={A Graph-Free Approach to Data-Flow Analysis},
  author={Markus Mohnen},
For decades, data-flow analysis (DFA) has been done using an iterative algorithm based on graph representations of programs. For a given data-flow problem, this algorithm computes the maximum fixed point (MFP) solution. The edge structure of the graph represents possible control flows in the program. In this paper, we present a new, graph-free algorithm for computing the MFP solution. The experimental implementation of the algorithm was applied to a large set of samples. The experiments clearly… 

Guiding Inlining Decisions Using Post-Inlining Transformations

This thesis defines this abstract notion of “benefit” through the use of static analysis and frequency information and shows that the proposed static analysis is comparable to heuristics in terms of compilation time, memory resources used during compilation, and impact on run time.

Combining Model Checking and Data-Flow Analysis

This chapter presents combined verification techniques in the framework of configurable program analysis, in order to emphasize techniques used in data-flow analysis and in model checking.

Combined Static and Dynamic Analysis

Simplifying the analysis of c++ programs

Two techniques are offered, one based on refining the type system of a language and the other on abstract interpretation, which allow developers to statically ensure or verify various run-time properties of their programs without having to deal with the full language semantics or even the abstract syntax tree of a program.

Fast Flexible Function Dispatch in Julia

The Julia language attempts to provide a more effective structure for technical computing by allowing programmers to express complex polymorphic behaviors using dynamic multiple dispatch over parametric types, and is reported on how this approach has allowed domain experts to express useful abstractions while simultaneously providing a natural path to better performance for high-level technical code.

Combining static and dynamic analysis to find multi-threading faults beyond data races

A new kind of generic analysis has been implemented in the JNuke framework presented here, which can utilize the same algorithm in both a static and dynamic setting by abstracting differences between the two scenarios into a corresponding environment.

Static Single Assignment for Decompilation

The goal of extending the state of the art of machine code decompilation has been achieved and the most promising areas for future research have been identified as range analysis and alias analysis.

Structural testing for message‐passing concurrent programs: an extended test model

The main contribution of the paper is to present a more flexible test model that provides improved coverage for message‐passing programs and at the same time reduces the cost of testing significantly.

Just-in-time performance without warm-up

This dissertation presents Scala Native, an optimizing compiler for Scala that is able to match and supersede the peak performance of HotSpot on the authors' benchmarks and introduces NIR, an intermediate representation designed with ahead-of-time compilation in mind.

Subroutine Inlining and Bytecode Abstraction to Simplify Static and Dynamic Analysis



Basic-Block Graphs: Living Dinosaurs?

It is demonstrated that edge-labeled SI-graphs, which model statements in their edges instead of in their nodes as classical flow graphs do, are most adequate, both for the theoretical reasoning about and for the implementation of analysis and optimization algorithms.

Escape analysis for object-oriented languages: application to Java

The main originality of the escape analysis is that it determines precisely the effect of assignments, which is necessary to apply it to object oriented languages with promising results, whereas previous work applied it to functional languages and were very imprecise on assignments.

Escape analysis: correctness proof, implementation and experimental results

An escape analysis, used to determine whether the lifetime of data exceeds its static scope, and a new correctness proof starting directly from a semantics, which takes into account all the features of functional languages, including imperative features and polymorphism.

Cache-conscious structure definition

A program's cache performance can be improved by changing the organization and layout of its data---even complex, pointer-based data structures. Previous techniques improved the cache performance of

Cache-conscious structure layout

It is demonstrated that careful data organization and layout provides an essential mechanism to improve the cache locality of pointer-manipulating programs and consequently, their performance.

Optimising the memory management of higher order functional programs

This paper focuses on explicit deallocation of heap allocated objects in traditional programming languages like Pascal, C, or Ada, where recursive dynamic data structures like lists or trees are available by explicit access to the heap of the runtime system.

Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints

A program denotes computations in some universe of objects. Abstract interpretation of programs consists in using that denotation to describe computations in another universe of abstract objects, so

Advanced Compiler Design and Implementation

Advanced Compiler Design and Implementation by Steven Muchnick Preface 1 Introduction to Advanced Topics 1.1 Review of Compiler Structure 1.2 Advanced Issues in Elementary Topics 1.3 The Importance

Byte Code Engineering

  • M. Dahm
  • Computer Science
  • 1999
A general purpose framework for the static analysis and dynamic creation or transformation of byte code is developed and its main features and possible application areas are presented.

Compilers: Principles, Techniques, and Tools

  • A. AhoR. SethiJ. Ullman
  • Computer Science
    Addison-Wesley series in computer science / World student series edition
  • 1986
This book discusses the design of a Code Generator, the role of the Lexical Analyzer, and other topics related to code generation and optimization.