Intermediate representations in imperative compilers

Stanier, James; Watson, D. M. S.

doi:10.1145/2480741.2480743

Cited by 18 publications

(13 citation statements)

References 47 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Many different IRs emerged for simplifying program analysis and optimizations [Stanier and Watson 2013]. The RVSDG is related to SSA [Cytron et al 1989], gated SSA [Tu and Padua 1995], and thinned gated SSA [Havlak 1993].…”

Section: Intermediate Representationsmentioning

confidence: 99%

See 1 more Smart Citation

Perfect Reconstructability of Control Flow from Demand Dependence Graphs

Bahmann

Reißmann

Jahre

et al. 2015

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

Demand-based dependence graphs (DDGs), such as the (Regionalized) Value State Dependence Graph ((R)VSDG), are intermediate representations (IRs) well suited for a wide range of program transformations. They explicitly model the flow of data and state, and only implicitly represent a restricted form of control flow. These features make DDGs especially suitable for automatic parallelization and vectorization, but cannot be leveraged by practical compilers without efficient construction and destruction algorithms. Construction algorithms remodel the arbitrarily complex control flow of a procedure to make it amenable to DDG representation, whereas destruction algorithms reestablish control flow for generating efficient object code. Existing literature presents solutions to both problems, but these impose structural constraints on the generatable control flow, and omit qualitative evaluation.The key contribution of this article is to show that there is no intrinsic structural limitation in the control flow directly extractable from RVSDGs. This fundamental result originates from an interpretation of loop repetition and decision predicates as computed continuations, leading to the introduction of the predicate continuation normal form. We provide an algorithm for constructing RVSDGs in predicate continuation form, and propose a novel destruction algorithm for RVSDGs in this form. Our destruction algorithm can generate arbitrarily complex control flow; we show this by proving that the original CFG an RVSDG was derived from can, apart from overspecific detail, be reconstructed perfectly. Additionally, we prove termination and correctness of these algorithms. Furthermore, we empirically evaluate the performance, the representational overhead at compile time, and the reduction in branch instructions compared to existing solutions. In contrast to previous work, our algorithms impose no additional overhead on the control flow of the produced object code. To our knowledge, this is the first scheme that allows the original control flow of a procedure to be recovered from a DDG representation.

show abstract

Section: Intermediate Representationsmentioning

confidence: 99%

“…The main intermediate representation (IR) for imperative languages in modern compilers is the Control Flow Graph (CFG) [Stanier and Watson 2013]. It explicitly encodes arbitrarily complex control flow, admitting unconstrained control flow optimizations and efficient object code generation.…”

Section: Introductionmentioning

confidence: 99%

Perfect Reconstructability of Control Flow from Demand Dependence Graphs

Bahmann

Reißmann

Jahre

et al. 2015

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

show abstract

“…a sea of IR nodes [17] and E-PEG [78]). However, these IRs complicate the debugging process of program compilation, and are seldom used in real-world, mainstream compilers [74]. Although we did not consider using these IRs, it would be an interesting direction for our future work, particularly when targeting parallel architectures.…”

Section: A More On Intermediate Represen-tationsmentioning

confidence: 99%

How to Architect a Query Compiler

Shaikhha

Klonatos

Parreaux

et al. 2016

Proceedings of the 2016 International Conference on Management of Data

View full text Add to dashboard Cite

This paper studies architecting query compilers. The state of the art in query compiler construction is lagging behind that in the compilers field. We attempt to remedy this by exploring the key causes of technical challenges in need of well founded solutions, and by gathering the most relevant ideas and approaches from the PL and compilers communities for easy digestion by database researchers. All query compilers known to us are more or less monolithic template expanders that do the bulk of the compilation task in one large leap. Such systems are hard to build and maintain. We propose to use a stack of multiple DSLs on different levels of abstraction with lowering in multiple steps to make query compilers easier to build and extend, ultimately allowing us to create more convincing and sustainable compiler-based data management systems. We attempt to derive our advice for creating such DSL stacks from widely acceptable principles. We have also re-created a well-known query compiler following these ideas and report on this effort.

show abstract

“…The GADT pattern-matching above may give a false sense of safety to the programmer -in fact, the latest version of the Scala compiler 4 will happily compile the same code but where f ( beta ( a )) has been replaced by f ( Const (1) On the other hand, the need often arises for more advanced IRs than plain AST [Stanier and Watson 2013], such as ANF (Administrative Normal Form) [Flanagan et al 1993], SSA (Static Single Assignment) or CFG (Control Flow Graph). This is particularly important when DSLs start incorporating effects and mutability, where evaluation order and aliasing become significant.…”

Section: Explicit Approachmentioning

confidence: 99%

Squid: type-safe, hygienic, and reusable quasiquotes

Parreaux

Shaikhha

Koch

2017

Proceedings of the 8th ACM SIGPLAN International Symposium on Scala

View full text Add to dashboard Cite

Quasiquotes have been shown to greatly simplify the task of metaprogramming. This is in part because they hide the data structures of the intermediate representation (IR), instead allowing metaprogrammers to use the concrete syntax of the language they manipulate. Scala has had "syntactic" quasiquotes for a long time, but still misses a statically-typed version like in MetaOCaml, Haskell and F#. This safer flavor of quasiquotes has been particularly useful for staging and domain-specific languages. In this paper we present Squid, a metaprogramming system for Scala that fills this gap. Squid quasiquotes are novel in three ways: they are the first statically-typed quasiquotes we know that allow code inspection (via pattern matching); they are implemented purely as a macro library, without modifications to the compiler; and they are reusable in the sense that they can manipulate different IRs. Adapting (or binding) a new IR to Squid is done simply by implementing a well-defined interface in the style of object algebras (i.e., tagless-final). We detail how Squid is implemented, leveraging the metaprogramming tools already offered by Scala, and show three application examples: the definition of a binding for a DSL in the style of LMS; a safe ANF conversion; and the introduction of type-safe, hygienic macros as an alternative to the current macro system.

show abstract

Intermediate representations in imperative compilers

Cited by 18 publications

References 47 publications

Perfect Reconstructability of Control Flow from Demand Dependence Graphs

Perfect Reconstructability of Control Flow from Demand Dependence Graphs

How to Architect a Query Compiler

Squid: type-safe, hygienic, and reusable quasiquotes

Contact Info

Product

Resources

About