Chap 10 intermediate representations
1 / 28

Chap. 10, Intermediate Representations - PowerPoint PPT Presentation

  • Uploaded on

Chap. 10, Intermediate Representations. J. H. Wang Dec. 27, 2011. Outline. Overview Java Virtual Machine Static Single Assignment Form. Overview. Ch.7: AST Ch.8-9: Semantic analysis Ch.10: Intermediate representation Ch.11: Code generation for a virtual machine Ch.12: Runtime support

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about ' Chap. 10, Intermediate Representations' - adair

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Chap 10 intermediate representations

Chap. 10, Intermediate Representations

J. H. Wang

Dec. 27, 2011


  • Overview

  • Java Virtual Machine

  • Static Single Assignment Form


  • Ch.7: AST

  • Ch.8-9: Semantic analysis

  • Ch.10: Intermediate representation

  • Ch.11: Code generation for a virtual machine

  • Ch.12: Runtime support

  • Ch.13: Target code generation


  • Semantic gap between high-level source languages and target machine language

  • Examples

    • Early C++ compilers

      • cpp: preprocessor

      • cfront: translate C++ into C

      • C compiler

Another example
Another Example

  • LaTeX

    • TeX: designed by Donald Knuth

    • dvi: device-independent intermediate representation

    • Ps: PostScript

    • pixels

  • Portability enhanced


  • Challenges

    • An intermediate language (IL) must be precisely defined

    • Translators and processors must be crafted for an IL

    • Connections must be made between levels so that feedback from intermediate steps can be related to the source program

  • Other concerns

    • Efficiency

The middle end
The Middle-End

  • Front-end: parser

  • Back-end: code generator

  • Middle-end: components between front- and back-ends

  • Compiler suites that host multiple source languages and target multiple instruction sets obtain great leverage from a middle-end

    • Ex: s source languages, t target languages

      • s*t vs. s+t

Additional advantages
Additional Advantages

  • An IL allows various system components to interoperate by facilitating access to information about the program

    • E.g. variable names and types, and source line numbers could be useful in the debugger

  • An IL simplifies development and testing of system components

  • The middle-end contains phases that would otherwise be duplicated among the front- and back-ends

  • It allows components and tools to interface with other products

  • It can simply the pioneering and prototyping of news ideas

  • The ILs and its interpreter can serve as a reference definition of a language

  • Interpreters written for a well-defined IL are helpful in testing and porting compilers

  • An IL enables the crafting of a retargetable code generator, which greatly enhances its portability

    • Pascal: P-code

    • Java: JVM

    • Ada: DIANA (Descriptive Intermediate Attributed Notation for Ada)

Java virtual machine
Java Virtual Machine

  • Class files: binary encodings of the data and instructions in a Java program

  • Design principles

    • Compactness

      • Instructions in nearly zero-address form

        • A runtime stack is used

        • Operands are implicit

          • E.g.: iadd instruction

        • A loss of runtime performance

      • Multiple instructions to accomplish the same effect

        • To push 0 on TOS

          • iconst_0, ldc_w 0

  • Safety

    • An instruction can reference storage only if it is of the type allowed by the instruction, and only if the storage is located in an area appropriate for access

    • From security’s point of view, purely zero-address form is problematic

      • The registers that could be accessed by a load instruction may not be known until runtime

      • JVM: not zero-address

        • E.g. iload 5

    • When a class file is loaded, many other checks are performed by the bytecode verifier

Contents of a class file
Contents of a Class File

  • Attributes that contain various information about the compiled class

    • Types: primitive and reference types

    • (Fig. 10.4)

      • Primitive type: a single character

      • Reference type t: Lt

        • E.g.: String type in java.lang package: Ljava/lang/String;

  • Constant pools

    • tagged union

      • int, float, java.lang.String

    • Referenced by its ordinal position, not byte-offset

Jvm instructions
JVM Instructions

  • Arithmetic

  • Register traffic

  • Registers and types

  • Static fields

  • Instance fields

  • Branching

  • Other method calls

  • Stack operations


  • int: 32-bit, 2’s complement

    • iadd

  • fadd(float)

  • ladd(long)

  • dadd(double)

Register traffic
Register Traffic

  • JVM has an unlimited number of virtual registers

  • JVM registers typically host a method’s local variables

  • JVM registers are untyped

    • iload 2

      • iload_2: abbreviated

    • istore 10

    • aload and astore: for reference types

Registers and types
Registers and Types

  • Static analysis (or bytecode verification)

    • To ensure that values flow in and our of registers without compromising Java’s type systems

  • Type conversion

    • i2f

Static fields
Static Fields

  • getstatic

    • E.g.: getstatic java/lang/System/out Ljava/io/PrintStream;

  • putstatic

Instance fields
Instance Fields

  • A class can declare instance field for which instance-specific storage is allocated

  • getfield

    • getfiled Point/x I

  • putfield

    • putfield Point/x I


  • ifeq, ifne, iflt, ifle, ifgt, ifge

  • if_icmpeq, if_icmpne, if_icmplt, if_icmple, if_icmpgt, if_icmpge

Static method calls
Static Method Calls

  • invokestatic

    • invokestatic java/lang/Math/pow(DD)D

Instance specific method calls
Instance-Specific Method Calls

  • invokevirtual

    • invokevirtual java/io/PrintStream/print(Z)V