Classes. Compiling Methods. Code Generation for Objects. Implementing Objects. Methods. Fields

Transcription

1 Classes Implementing Objects Components fields/instance variables values differ from to usuall mutable methods values shared b all s of a class usuall immutable component visibilit: public/private/protected CS 412/413 Spring 2008 Introduction to Compilers 2 Code Generation for Objects Methods Generating method Generating method calls (dispatching) Constructors and destructors Fields Memor laout Generating to access fields Field alignment Compiling Methods Methods look like functions, are tpe-checked like functions what is different? Argument list: implicit receiver argument Calling sequence: use dispatch vector instead of jumping to absolute address CS 412/413 Spring 2008 Introduction to Compilers 3 CS 412/413 Spring 2008 Introduction to Compilers 4

2 The Need for Dispatching Eample: interface Point { int (); int (); float (); class ColoredPoint implements Point { float () { return sqrt(*+*); class 3DPoint implements Point { float () { return sqrt(*+*+z*z); Point p; if (cond) p = new ColoredPoint(); else p = new 3DPoint(); float n = p.(); Compiler can t tell what to run when method is called! Dnamic Dispatch Solution: dispatch vector (dispatch table, selector table ) Entries in the table are pointers to method Method entr point is computed dnamicall! If T <: S, then vector for s of tpe S is a prefi of vector for s of tpe T reference p laout dispatch vector method CS 412/413 Spring 2008 Introduction to Compilers 5 CS 412/413 Spring 2008 Introduction to Compilers 6 Objects of same tpe Dnamic dispatch (contd.) reference p q reference laout laout dispatch vector method Wh It Works If S <: T and f is a method of an of tpe T, then Objects of tpe S inherit f; f can be overridden b S Pointer to f has same inde in the for tpe T and S! Staticall generate to look up pointer to method f Pointer values determined dnamicall Point reference p 3DPoint laout z 3DPoint vector getz 3DPoint 3DPoint CS 412/413 Spring 2008 Introduction to Compilers 8

3 Dispatch Vector Lookup Ever method has its own integer inde Inde is used to look up method in dispatch vector interface A { C <: B <: A void f(); f(); 0 A f class B implements A { void f() f() { 0 B f,g,h void g() g() { 1 void h() h() { 2 C f,g,h,e class C etends B { void e() e() { 3 Dispatch Vector Laouts Inde of f is the same in an of tpe T <: A Methods ma have multiple implementations For subclasses with unrelated tpes If subclass overrides method To eecute a method i: Lookup entr i in vector Eecute pointed to b entr value A B C f f g h f g h e CS 412/413 Spring 2008 Introduction to Compilers 9 CS 412/413 Spring 2008 Introduction to Compilers 10 Code Generation: Dispatch Vectors Allocate one dispatch vector per class Objects of same class eecute same method Staticall allocate dispatch vectors.data A_:.long _f _f.data B_:.long _f _f.long _g _g.long _h _h.data C_:.long _f _f.long _g _g.long _h _h.long _e _e Interfaces, Abstract Classes Classes define a tpe and some values (methods) Interfaces are pure tpes : no implementation no dispatch vector: onl a laout Abstract classes are halfwa: define some methods leave others unimplemented no s (instances) of abstract class needed onl for concrete classes CS 412/413 Spring 2008 Introduction to Compilers 11 CS 412/413 Spring 2008 Introduction to Compilers 12

4 Method Arguments Methods have a special variable (Java, C++: this) called the receiver Historicall (Smalltalk): method calls thought of as messages sent to receivers Receiver is (implicit) argument to method Static Methods In Java, can declare methods static the have no receiver Called eactl like al functions don t need to call via dispatch vector don t need implicit etra argument for receiver class A { int intf(int,, int int) ) { compile as int intf(a f(athis, int int,, int int) ) { Treated as methods as wa of getting functions inside the class scope (access to module internals for semantic analsis) Not reall methods CS 412/413 Spring 2008 Introduction to Compilers 13 CS 412/413 Spring 2008 Introduction to Compilers 14 Code Generation: Method Calls Eample Code for function calls: pre-call + post-call Pre-function-call : Save registers Push parameters Pre-method call: Save registers Push parameters Push receiver reference Lookup method in dispatch vector o.foo(2,3); ea eb [eb+4] foo foo () () () push $3 $3 push $2 $2 push %ea mov (%ea), %eb call call *4(%eb) add $12, %esp CS 412/413 Spring 2008 Introduction to Compilers 15 CS 412/413 Spring 2008 Introduction to Compilers 16

5 Object consists of: Methods Fields Object Laout Object laout consists of: Pointer to, which contains pointers to methods Fields laout (static data) () Allocation of Objects Objects can be stack- or heap-allocated Stack allocation: (C++) Point p; Heap: (C++) Point *p = new Point; (Java) Point p = new Point(); (stack) p (stack) (heap) (static data) (static data) CS 412/413 Spring 2008 Introduction to Compilers 17 CS 412/413 Spring 2008 Introduction to Compilers 18 Inheritance and Object Laout Inheritance and Object Laout Method copied down from superclass if not overridden b subclass Fields also inherited (needed b inherited in general) Inheritance: add fields, methods Etend laout Etend dispatch vector A supertpe can be used whenever a subtpe can be used CS 412/413 Spring 2008 Introduction to Compilers 19 LL: Point UR: Point Shape class class Shape { Point LL, LL, UR; UR; void void setcorner(int which, Point p); p); class class ColoredRect etends Shape { int intcolor; void void setcolor(int col); col); setcorner LL: Point UR: Point color: int ColoredRect setcorner setcolor CS 412/413 Spring 2008 Introduction to Compilers 20

6 Code Sharing Field Offsets LL: Point UR: Point LL: Point UR: Point color: int setcorner setcorner setcolor Machine for Shape.setCorner Don t actuall cop! Works with separate compilation: can inherit without superclass source Offsets of fields from beginning of known staticall, same for all subclasses Eample: class Shape { Point LL LL /* /* 4 */ */,, UR; /* /* 8 */ */ void setcorner(int which, Point p); p); class ColoredRect etends Shape { Color c; c; /* /* */ */ void setcolor(color c_); Offsets known for stack and heap allocated s CS 412/413 Spring 2008 Introduction to Compilers 21 CS 412/413 Spring 2008 Introduction to Compilers 22 Field Alignment In man processors, a 32-bit load must be to an address divisible b 4, address of 64-bit load must be divisible b 8 In rest (e.g., Pentium), loads are 10 faster if aligned -- avoids etra load Fields should be aligned c struct { int ; char c; int ; char d; int z; double e; CS 412/413 Spring 2008 Introduction to Compilers 23 d z e Accessing Fields Access fields of current Access equivalent to this. Current method has this as argument Access fields of other s Access of the form o. In both cases: Use pointer to Add offset to the field Access o. depends on the kind of allocation of o Stack allocation: stack access (%epb + stack offset) Heap allocation: stack access + dereference CS 412/413 Spring 2008 Introduction to Compilers 24

7 Code Generation: Allocation Heap allocation: o = new LenList() Allocate heap space for Store pointer to dispatch vector Stack allocation: Push on stack Pointer to on stack push $16 # 3 fields+ call call _GC_malloc mov $LenList_, (%ea) add $4, $4, %esp #pop $16 mov $ea, disp o (%ebp) o sub sub $16, %esp # 3 fields+ mov $LenList_, -4(%ebp) Constructors Java, C++: classes can declare constructors that initialize new s: class LenList { int len; Cell head, tail; LenList() { len = 0;... new LenList(); Need to know when s are constructed Heap:new statement Stack:at the beginning of their scope (blocks for locals, procedures for arguments, program for globals) CS 412/413 Spring 2008 Introduction to Compilers 25 CS 412/413 Spring 2008 Introduction to Compilers 26 Compiling Constructors Compiled like methods: pseudo-variable this passed to constructor return value is this o = new LenList(); LenList() { len = 0; push $1 $1 # 3 fields+ call call _GC_malloc mov $LenList_, (%ea) add add $4, $4, %esp push %ea call call LenList$constructor add add $4, $4, %esp mov %ea, disp disp o (%ebp) o LenList$constructor: push %ebp mov %esp,%ebp mov 8(%ebp), ea ea mov $0, $0, 4(%ea) mov %ebp,%esp pop pop %ebp ret ret Destructors In some languages (e.g., C++), s can also declare to eecute when s are destructed Heap: when invoking delete (eplicit de-allocation) Stack: when scope of variables ends End of blocks for local variables End of program for global variables End of procedure for function arguments CS 412/413 Spring 2008 Introduction to Compilers 27 CS 412/413 Spring 2008 Introduction to Compilers 28

8 Analsis and Optimizations Dataflow analsis reasons about variables and values Records (s) consist of a collection of variables (fields) analsis must separatel keep track of individual fields Difficult analsis for heap-allocated s Object lifetime outlives procedure lifetime Need to perform inter-procedural analsis Constructors/destructors: must take their effects into account Class Hierarch Analsis Method calls = dnamic, via dispatch vectors Overhead of going through Prohibits function inlining Makes other inter-procedural analses less precise Static analsis of dnamic method calls Determine possible methods invoked at each call site Need to determine principal tpes of s at each program point (Class Hierarch Analsis) If analsis determines o is alwas of tpe T (not subtpe), then it precisel knows the for o.foo() Optimizations: transform dnamic method calls into static calls, inline method calls CS 412/413 Spring 2008 Introduction to Compilers 29 CS 412/413 Spring 2008 Introduction to Compilers 30 Summar Method dispatch accomplished using dispatch vector, implicit method receiver argument No dispatch of static methods needed Inheritance causes etension of fields as well as methods; can be shared Field alignment: declaration order matters! Each real class has a single dispatch vector in data segment: installed at creation or constructor Analsis more difficult in the presence of s Class hierarch analsis = precisel determine class CS 412/413 Spring 2008 Introduction to Compilers 31