chap 10 intermediate representations n.
Download
Skip this Video
Download Presentation
Chap. 10, Intermediate Representations

Loading in 2 Seconds...

play fullscreen
1 / 28

Chap. 10, Intermediate Representations - PowerPoint PPT Presentation


  • 115 Views
  • 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

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

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


Download Now 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
outline
Outline
  • Overview
  • Java Virtual Machine
  • Static Single Assignment Form
overview
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
  • Ch.13: Target code generation
overview1
Overview
  • 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
Challenges
  • 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
slide12
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
slide14
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;
slide17
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
arithmetic
Arithmetic
  • 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
branching
Branching
  • 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