This paper proposes an extensional semantics-based formal specification of secure information-flow properties in sequential programs based on representing degrees of security by partial equivalence relations (pers). The specification clarifies and unifies a number of specific correctness arguments in the literature and connections to other forms of program analysis. The approach is inspired by (and in the deterministic case equivalent to) the use of partial equivalence relations in specifying binding-time analysis, and is thus able to specify security properties of higher-order functions and "partially confidential data". We also show how the per approach can handle nondeterminism for a first-order language, by using powerdomain semantics and show how probabilistic security properties can be formalised by using probabilistic powerdomain semantics. We illustrate the usefulness of the compositional nature of the security specifications by presenting a straightforward correctness proof for a simple type-based security analysis.

this article, we present a general framework for developing demand-driven interprocedural data flow analyzers and report our experience in evaluating the performance of this approach. A demand for data flow information is modeled as a set of queries. The framework includes a generic demand-driven algorithm that determines the response to a query by iteratively applying a system of query propagation rules. The propagation rules yield precise responses for the class of distributive finite data flow problems. We also describe a two-phase framework variation to accurately handle nondistributive problems. A performance evaluation of our demand-driven approach is presented for two data flow problems, namely, reaching-definitions and copy constant propagation. Our experiments show that demand-driven analysis performs well in practice, reducing both time and space requirements when compared with exhaustive analysis.

: We advocate the use of operational semantics as a basis for specifying program analyses for functional languages. We put forward a methodology for defining a static analysis by successive refinements of the natural semantics of the language. We use paths as the abstract representation of proof trees and we provide a language for defining properties in terms of recurrence equations on paths. We show the specification of several standard properties on paths (neededness, absence, uniqueness, : : : ) and the mechanical derivation of the corresponding analyses. Key-words: functional languages, operational semantics, neededness analysis, paths analysis, optimising compilers. (R'esum'e : tsvp) gouranto@irisa.fr lemetaye@irisa.fr Unite de recherche INRIA Rennes IRISA, Campus universitaire de Beaulieu, 35042 RENNES Cedex (France) Telephone : (33) 99 84 71 00 -- Telecopie : (33) 99 84 71 D'erivation d'analyseurs de programmes fonctionnels `a partir de propri'et'es de chemin d'une s'ema...

We extend the strictness and totality analysis of [12] by allowing conjunction at all levels rather than at the top-level. We prove the strictness and totality analysis correct with respect to a denotational semantics and finally construct an algorithm for inferring the strictness and totality properties. 1 Introduction Strictness analysis has proved useful in the implementation of lazy functional languages like Miranda, Lazy ML and Haskell: when a function is strict it is safe to evaluate its argument before performing the function call. Totality analysis has not been adopted so widely: if the argument to a function is known to terminate then it is safe to evaluate it before performing the function call [9]. In the literature there are several approaches to the specification of strictness analysis: abstract interpretation (e.g. [10, 3]), projection analysis (e.g. [14]) and inference based methods (e.g. [2, 6, 7, 8, 15]). Totality analysis has received much less attention and has pri...

Introduction Types have been recognized as useful in programming languages because they provide a semantical (context dependent) analysis of programs. Such analysis can be incorporated in the compiling process, and it is used on one side to check the consistency of programs and on the other to improve the efficiency of the code produced.

In this paper, we propose a common theoretical framework for type based static analyses. The aim is the study of relationships between typing and program analysis. We present a