7,448 research outputs found
Program representation size in an intermediate language with intersection and union types
The CIL compiler for core Standard ML compiles whole programs using a novel typed intermediate language (TIL) with intersection and union types and flow labels on both terms and types. The CIL term representation duplicates portions of the program where intersection types are introduced and union types are eliminated. This duplication makes it easier to represent type information and to introduce customized data representations. However, duplication incurs compile-time space costs that are potentially much greater than are incurred in TILs employing type-level abstraction or quantification. In this paper, we present empirical data on the compile-time space costs of using CIL as an intermediate language. The data shows that these costs can be made tractable by using sufficiently fine-grained flow analyses together with standard hash-consing techniques. The data also suggests that non-duplicating formulations of intersection (and union) types would not achieve significantly better space complexity.National Science Foundation (CCR-9417382, CISE/CCR ESS 9806747); Sun grant (EDUD-7826-990410-US); Faculty Fellowship of the Carroll School of Management, Boston College; U.K. Engineering and Physical Sciences Research Council (GR/L 36963, GR/L 15685
Type-Directed Weaving of Aspects for Polymorphically Typed Functional Languages
Incorporating aspect-oriented paradigm to a polymorphically typed functional
language enables the declaration of type-scoped advice, in which the
effect of an aspect can be harnessed by introducing possibly polymorphic
type constraints to the aspect. The amalgamation of aspect orientation and
functional programming enables quick behavioral adaption of functions, clear
separation of concerns and expressive type-directed programming. However,
proper static weaving of aspects in polymorphic languages with a type-erasure
semantics remains a challenge. In this paper, we describe a type-directed
static weaving strategy, as well as its implementation, that supports
static type inference and static weaving of programs written in an aspect-oriented
polymorphically typed functional language, AspectFun. We show
examples of type-scoped advice, identify the challenges faced with compile-time
weaving in the presence of type-scoped advice, and demonstrate how
various advanced aspect features can be handled by our techniques. Lastly,
we prove the correctness of the static weaving strategy with respect to the
operational semantics of AspectFun
On the Pursuit of Static and Coherent Weaving
Aspect-oriented programming (AOP) has been shown to be a useful
model for software development. Special care must be taken
when we try to adapt AOP to strongly typed functional languages
which come with features like type inference mechanism, polymorphic
types, higher-order functions and type-scoped pointcuts.
Specifically, it is highly desirable that weaving of aspect-oriented
functional programs can be performed statically and coherently. In
[13], we showed a type-directed weaver which resolves all advice
chainings coherently at static time. The novelty of this paper lies in
the extended framework which supports static and coherent weaving
in the presence of polymorphic recursive functions, advising
advice bodies and higher-order advices
Information flow analysis for a dynamically typed language with staged metaprogramming
Web applications written in JavaScript are regularly used for dealing with sensitive or personal data. Consequently, reasoning about their security properties has become an important problem, which is made very difficult by the highly dynamic nature of the language, particularly its support for runtime code generation via eval. In order to deal with this, we propose to investigate security analyses for languages with more principled forms of dynamic code generation. To this end, we present a static information flow analysis for a dynamically typed functional language with prototype-based inheritance and staged metaprogramming. We prove its soundness, implement it and test it on various examples designed to show its relevance to proving security properties, such as noninterference, in JavaScript. To demonstrate the applicability of the analysis, we also present a general method for transforming a program using eval into one using staged metaprogramming. To our knowledge, this is the first fully static information flow analysis for a language with staged metaprogramming, and the first formal soundness proof of a CFA-based information flow analysis for a functional programming language
Simple and Effective Type Check Removal through Lazy Basic Block Versioning
Dynamically typed programming languages such as JavaScript and Python defer
type checking to run time. In order to maximize performance, dynamic language
VM implementations must attempt to eliminate redundant dynamic type checks.
However, type inference analyses are often costly and involve tradeoffs between
compilation time and resulting precision. This has lead to the creation of
increasingly complex multi-tiered VM architectures.
This paper introduces lazy basic block versioning, a simple JIT compilation
technique which effectively removes redundant type checks from critical code
paths. This novel approach lazily generates type-specialized versions of basic
blocks on-the-fly while propagating context-dependent type information. This
does not require the use of costly program analyses, is not restricted by the
precision limitations of traditional type analyses and avoids the
implementation complexity of speculative optimization techniques.
We have implemented intraprocedural lazy basic block versioning in a
JavaScript JIT compiler. This approach is compared with a classical flow-based
type analysis. Lazy basic block versioning performs as well or better on all
benchmarks. On average, 71% of type tests are eliminated, yielding speedups of
up to 50%. We also show that our implementation generates more efficient
machine code than TraceMonkey, a tracing JIT compiler for JavaScript, on
several benchmarks. The combination of implementation simplicity, low
algorithmic complexity and good run time performance makes basic block
versioning attractive for baseline JIT compilers
- …