For a compiler writer, generating good machine code for a variety of platforms is hard work. One might try to reuse a retargetable code generator, but code generators are complex and difficult to use, and they limit one's choice of implementation language. One might try to use C as a portable assembly language, but C limits the compiler writer's flexibility and the performance of the resulting code. The wide use of C, despite these drawbacks, argues for a portable assembly language. C-- is a new language designed expressly for this purpose. The use

Process migration and atomic transactions are essential tools for constructing fault-tolerant distributed systems. We present a new system that includes a typed intermediate language and runtime implementation designed to support these services. The language is type-safe and general enough to support front-ends for both type-safe and unsafe languages. We include benchmarks for programs written in ML and ANSI C.

Abstract. As parallelism in microprocessors becomes mainstream, new programming languages and environments are emerging to meet the challenges of parallel programming. To support research on these languages, we are developing a lowlevel language infrastructure called Pillar (derived from Parallel Implementation Language). Although Pillar programs are intended to be automatically generated from source programs in each parallel language, Pillar programs can also be written by expert programmers. The language is defined as a small set of extensions to C. As a result, Pillar is familiar to C programmers, but more importantly, it is practical to reuse an existing optimizing compiler like gcc [1] or Open64 [2] to implement a Pillar compiler. Pillar’s concurrency features include constructs for threading, synchronization, and explicit data-parallel operations. The threading constructs focus on creating new threads only when hardware resources are idle, and otherwise executing parallel work within existing threads, thus minimizing thread creation overhead. In addition to the usual synchronization constructs, Pillar includes transactional memory. Its sequential features include stack walking, second-class continuations, support for precise garbage collection, tail calls, and seamless integration of Pillar and legacy code. This paper describes the design and implementation of the Pillar software stack, including the language, compiler, runtime, and high-level converters (that translate high-level language programs into Pillar programs). It also reports on early experience with three high-level languages that target Pillar. 1

For a compiler writer, generating good machine code for a variety of platforms is hard work. One might try to reuse a retargetable code generator from another compiler, but code generators are complex and difficult to use, and they limit one's choice of implementation language. One might try to use C as a portable assembly language, but C limits the compiler writer's flexibility and the performance of the resulting code. The wide use of C, despite these drawbacks, argues for a portable assembly language. C-- is a new language designed expressly as a portable assembly language. C-- eliminates some of the performance problems associated with C, but in its originallyproposed form it does not provide adequate support for garbage collection, exception handling, and debugging. The problem is that neither the high-level compiler nor the C-- compiler has all of the information needed to support these run-time features. This paper proposes a three-part solution: new language constructs for C--,...

Process migration and atomic transactions are essential tools for constructing fault-tolerant distributed systems. Process migration provides location transparency, the ability to perform load-balancing and process checkpointing, and allows processes to be reconstructed after machine failures. Transactions provide fault-isolation by limiting the scope of errors, and permit speculative execution by allowing rollback of overly optimistic computations. We present a compiler that uses a typed intermediate language and a runtime implementation designed to support these services. Our intermediate language is type-safe and general enough to support front-ends for both type-safe and unsafe languages. In addition, our compiler is able to generate code for both ML and ANSI C programs. We include benchmarks that show that our compiler produces programs with competitive performance. 1.

Program specialization is normally supported by global analysis of the program. Compilers use the information deduced to generate more efficient, specialized implementations of the program. This specialization can be single or multiple, depending if each procedure of the program is specialized into one or more versions. We present a Prolog compiler that does multiple specialization, using an algorithm that works over the WAM code, deducing the reachable procedure activations based on local analysis. The idea is to use the analysis that is done in the Prolog to WAM compilation, and that generates local specialized instructions, and to propagate this information through the entire program. The creation of multiple versions of predicates allows the propagation to be inter-procedural, and to achieve global program specialization. Results from an implementation generating C code as target language are presented, showing a performance comparable to native code Prolog compilers. Keywords: P...

This report describes the new graph coloring register allocator that we have developed for the MLRISC customizable code generator. The new allocator has a more modular design, uses a sparse method for constructing the interference graph, and has incorporated some new features and algorithmic improvements, including support for frequency sensitive allocation, and spill reduction strategies. Preliminary benchmarks (by compiling the SML/NJ compiler) indicate that the new allocator is about 20% faster on RISC machines, which translates into 4% to 6% overall speedup in the compiler; but on the Intel x86, no speedup is obtained.

This paper introduces a monadic object code for functional languages that allows an architecture independent, compact representation of program modules; it includes support for distributed applications by featuring a light-weight thread model and asymmetric communication. It proposes to offset inefficiencies introduced by the architecture independence by specialising and optimizing the code before or during execution. The proposal is substantially different from classical bytecode in both the structure of the language, as it is a strongly-typed functional language encapsulating side-effects in monadic form, and the representation of the code, as it is a bit-aligned structurally, compressed code designed for runtime code-generation, not for interpretation.

I hereby declare that this thesis has not been submitted, either in the same or different form, to this or any other university for a degree.

Recent trends in programming language implementation are moving more and more towards “managed ” runtime environments. These offer many benefits, including static and dynamic type checking, security, profiling, bounds checking and garbage collection. The Common Language Infrastructure (CLI) is Microsoft’s attempt to define a managed runtime environment. However, since it was designed with more mainstream languages in mind, including C ♯ and C++, CLI proves restrictive when compiling functional languages. More specifically, for compilers such as GHC, which compiles Haskell, the CLI provides little support for lazy evaluation, currying (partial applications) and static type checking. The CLI does not provide any way of representing a computation in an evaluated and non-evaluated form. It does not allow functions to directly manipulate the runtime stack, and it restricts static typing in various forms; including subsumption over function types. In this thesis, we describe a new compilation method that removes the need for runtime argument checks. Runtime argument checking is required to