Why are intermediate codes useful for porting compilers?

Intermediate codes allow a compiler to be split into a front-end (high-level language to intermediate code) and a back-end (intermediate code to specific machine binary). This modularity means only the back-end needs to be rewritten to target a new architecture.

How does the byte become the standard unit of computer architecture?

Over time, computer architectures converged towards using the byte (typically 8 bits) as the fundamental unit. This became prevalent despite earlier machines having different word sizes like 24, 36, or 60 bits.

What is the concept of a 'self-compiling compiler'?

A self-compiling compiler is when a compiler written in a certain language can compile itself. This technique is used for improving compiler quality or for bootstrapping purposes.

How can intermediate codes help improve compiler performance?

By using intermediate codes, compiler development can be divided into improving the front-end (generating better intermediate code) or the back-end (generating better binary from intermediate code). This modular approach allows for targeted enhancements.

What is the difference between interpreting and compiling intermediate code?

Interpreting intermediate code allows for slower but immediate execution and testing. Compiling intermediate code to binary produces faster, more efficient final programs, similar to what Java bytecode systems offer.

How can a compiler be improved using intermediate code?

One can improve a compiler by first generating better intermediate code (I*) from the high-level language (H) using an upgraded front-end. Then, a separate back-end can compile this improved intermediate code into better quality binary.

Improving Intermediate Codes - Computerphile

Computerphile

Education3 min read22 min video

Oct 4, 2019|56,384 views|1,531|78

computers computerphile computer science Computer Science University of Nottingham Professor Brailsford

Save to Pod

Key Moments

TL;DR

Computerphile explains how intermediate codes improve compiler portability and efficiency through T-diagrams.

Key Insights

Compilers transform high-level languages into machine-executable binary code.

Intermediate codes (like bytecode) act as a bridge between high-level languages and diverse machine architectures.

Using intermediate codes simplifies compiler porting to new architectures by separating front-end (language to intermediate) and back-end (intermediate to binary) concerns.

Improving a compiler can be a two-stage process: upgrading the front-end or the back-end, or both.

The convergence of computer architectures around byte addresses and powers-of-two units (e.g., 8-bit bytes) has made intermediate code efforts more standardized.

T-diagrams are a visual tool to analyze and understand the stages of compilation, especially with intermediate codes.

THE FUNDAMENTAL COMPILER PROCESS

Programs are written in high-level languages (like C) but do not execute directly. They must be compiled into machine-specific binary code. This compilation process involves transforming human-readable code into an executable format for a particular architecture. Early compiler efforts often focused on generating binary code directly, which presented challenges when porting to different machines or improving code quality.

THE RISE OF INTERMEDIATE CODES

To bridge the vast semantic gap between abstract high-level languages and concrete machine binaries, intermediate codes were developed. These codes serve as a common, abstract representation. Examples include Z-code and Java bytecode. LLVM is a modern system that exemplifies the successful use of intermediate representations, which has become less of a problem due to architectural convergence around byte addressing and powers-of-two basic units.

SIMPLIFYING COMPILER PORTING

Intermediate codes significantly simplify the task of porting a compiler to a new architecture. Instead of rewriting the entire compiler for each target, developers can focus on two distinct parts: the front-end (translating the source language to intermediate code) and the back-end (translating intermediate code to the target machine's binary). This modular approach makes adapting to different machines, like B-double-prime, far more manageable than direct binary generation.

IMPROVING CODE QUALITY VIA TWO-STAGE PROCESSES

Enhancing compiler performance or output quality can be approached using intermediate codes in a two-stage process. One can upgrade the front-end to produce better intermediate code, or the back-end to generate more efficient binary from the intermediate code. This allows for modular improvements, where either part can be refined independently or in conjunction with the other, leading to a better overall compiler output.

T-DIAGRAMS AS A VISUALIZATION TOOL

The video extensively uses T-diagrams, a visual notation system, to illustrate the complex processes involved in compilation, especially when intermediate codes are utilized. These diagrams help to map out the source texts, compilers, and executable binaries at various stages. This methodical breakdown aids in understanding how changes at one stage, such as improving the intermediate code generation, affect the overall compilation pipeline.

THE PRACTICAL APPLICATION OF INTERMEDIATE CODES

The practical application involves moving from a current system (e.g., B-prime) to a new target (B-double-prime). By using intermediate codes, a compiler written in H can produce intermediate code (I-star, a better version). This intermediate code can then be processed by a separate back-end component that generates binary for the new architecture. This modularity allows for a controlled 'invasion' of a new machine environment rather than a brute-force code dump.

ITERATIVE IMPROVEMENT AND RECOMPILATION

The process of improving a compiler, even with intermediate codes, often involves self-compilation. A compiler written in H that produces intermediate code can be used to compile itself. The resulting intermediate code can then be compiled into binary. This iterative approach, aided by T-diagrams, demonstrates how to achieve better quality intermediate code and subsequently better final binary outputs through systematic steps.

THE TRADE-OFFS OF INTERMEDIATE CODES

While intermediate codes offer significant advantages in portability and modularity, they do introduce additional stages into the compilation pipeline. This can initially seem like more complexity. However, the benefits of easier maintenance, targeted improvements, and adaptation to diverse architectures often outweigh the perceived overhead, especially in modern software development.

Mentioned in This Episode

●Products

●Software & Apps

●Tools

●Companies

●Concepts

●People Referenced

Common Questions

An intermediate code is a representation of source code that sits between the high-level language and the machine's binary code. It helps bridge the 'semantic gap' and simplifies tasks like compiler porting and optimization.