We introduce a general uniform language-independent framework for designing online and offline source-to-source program transformations by abstract interpretation of program semantics. Iterative source-to-source program transformations are designed constructively by composition of source-to-semantics, semantics-totransformed semantics and semantics-to-source abstractions applied to fixpoint trace semantics. The correctness of the transformations is expressed through observational and performance abstractions. The framework is illustrated on three examples: constant propagation, program specialization by online and offline partial evaluation and static program monitoring.

Given are a directed edge-labelled graph G with a distinguished node n0, and a regular expression P which may contain variables. We wish to compute all substitutions φ (of symbols for variables), together with all nodes n such that all paths n0 → n are in φ(P). We derive an algorithm for this problem using relational algebra, and show how it may be implemented in Prolog. The motivation for the problem derives from a declarative framework for specifying compiler optimisations. 1 Bob Paige and IFIP WG 2.1 Bob Paige was a long-standing member of IFIP Working Group 2.1 on Algorithmic Languages and Calculi. In recent years, the main aim of this group has been to investigate the derivation of algorithms from specifications by program transformation. Already in the mid-eighties, Bob was way ahead of the pack: instead of applying transformational techniques to well-worn examples, he was applying his theories of program transformation to new problems, and discovering new algorithms [16, 48, 52]. The secret of his success lay partly in his insistence on the study of general algorithm design strategies (in particular

Abstract. In this paper we introduce a semantic-based approach for code obfuscation. The aim of code obfuscation is to prevent malicious users to disclose properties of the original source program. This goal can be precisely modeled by abstract interpretation, where the hiding of properties corresponds to abstract the semantics. We derive a general theory based on abstract interpretation, where the potency of code obfuscation can be measured by comparing hidden properties in the lattice of abstract interpretations. Semantic-based code obfuscation is applied to show that well known program transformation methods, such as constant propagation, can be seen as code obfuscation.

. In this work we define a schematic language to concisely describe classes of logic programs. We show how our proposed formalism can be profitably employed to represent opportunities for program optimisation: we schematically specify commonly occurring inefficient portions of code and how these can be altered to improve the performance of programs. We have defined a fully automated approach to exploit these opportunities for the analysis and transformation of logic programs. Keywords. Logic program analysis & transformation, program schemata. 1 Introduction Research on program analysis [6] and transformation [7] aims at providing software practitioners with tools and methods for the development of correct and efficient computer systems. Within logic programming a wealth of theoretical results [8] have been accumulated over the years but they have not had the practical impact one would have wished. The work described here remedies this: we propose a practical approach for logi...

hereby granted, provided that this notice and the reference

Abstract. Chiba et al. (2005) proposed a framework of program transformation by template and automated verification of its correctness based on term rewriting. This paper describes a design and implementation of RAPT which implements this framework. RAPT transforms a term rewriting system according to a specified program transformation template. Presupposing the program transformation template is developed, the correctness of the transformation is automatically verified so that the transformation keeps the relationship between initial ground terms and their normal forms. 1

Program transformation by templates (Huet and Lang, 1978) is a technique to improve the efficiency of programs. In this technique, programs are transformed according to a given program transformation template. To enhance the variety of program transformation, it is important to introduce new transformation templates. Up to our knowledge, however, few works discuss about the construction of transformation templates. Chiba et al. (2006) proposed a framework of program transformation by template based on term rewriting and automated verification of its correctness. Based on this framework, we propose a method that automatically constructs transformation templates from similar program transformations. The key idea of our method is a second-order generalization, which is an extension of Plotkin’s firstorder generalization (1969). We give a second-order generalization algorithm and prove the soundness of the algorithm. We then report about an implementation of the generalization procedure and an experiment on the construction of transformation templates. 1.

This paper describes our work on extending typed - calculus to accommodate operations with typed, or homogeneous, sets. Functions play a prominent role in describing the semantics of a programming language, and -calculus, as a theory of functions, provides rules for manipulating functions in a purely syntactic manner. We extend typed -calculus with typed sets, and call the extension as Set-Enriched Typed -Calculus, or in short SET -calculus. We show the well-formedness of SET -calculus, and we include the proof of its soundness and completeness. This is part of our work on implementing functional languages with sets. 1 Introduction This paper describes our work on extending typed - calculus to accommodate operations with typed, or homogeneous, sets. We call this extension as Set-Enriched Typed -Calculus, or in short SET -calculus. The functional programming style is closely related to the use of higher-order functions. In particular, it suggests that many function definitions are ...

. This paper examines the application domains of the experimental scripting language Open PROMOL and its processor. The language processor EREBUS is an experimental tool aiming to support developing generic (reusable) components and building domain-specific program generators. Developing of generic VHDL components, data and program specialization for scientific algorithms, such as Chebyshev approximation, Fast Fourier Transformation (Glck et. al., [16]; Chirokoff et al., [11]) and program generalization are discussed. Examples and experimental results are given. #. Introduction In general, for developing the component-based software systems, we need to use two languages. The first is a target language (TL) aiming to implement components. The second is a scripting language (ScL) used to configure and plug components into a system. A TL may be either a conventional programming language, such as C++, Java, etc., or a domain-specific language (DSL), such as VHDL. We consider compone...

In recent years code obfuscation has attracted research interest as a promising technique for protecting secret properties of programs. The basic idea of code obfuscation is to transform programs in order to hide their sensitive information while preserving their functionality. One of the major drawbacks of code obfuscation is the lack of a rigorous theoretical framework that makes it difficult to formally analyze and certify the effectiveness of obfuscating techniques. We face this problem by providing a formal framework for code obfuscation based on abstract interpretation and program semantics. In particular, we show that what is hidden and interpretations of program semantics. Being able to specify what is masked and what is preserved by an obfuscation allows us to understand its potency, namely the amount of obscurity that the transformation adds to programs. In the proposed framework, obfuscation and attackers are modeled as approximations of program semantics and the lattice of abstract interpretations provides a formal tool for comparing obfuscations with respect to their potency. In particular, we prove that our framework provides an adequate setting to measure not only the potency of an obfuscation but also its resilience, i.e., the difficulty of undoing the obfuscation. We consider code obfuscation by opaque predicate insertion and we show how the degree of abstraction needed to disclose different opaque predicates allows us to compare their potency and resilience.