Programming Languages

Transcription

1 TEHNISHE UNIVERSITÄT MÜNHEN FKULTÄT FÜR INFORMTIK Programming Languages Multiple Inheritance Dr. Michael Petter Winter term 2014 Multiple Inheritance 1 / 44

2 Inheritance Principles 1 Interface Inheritance Outline 2 Implementation Inheritance 3 Liskov Substition Principle and Shapes ++ Object Heap Layout 1 asics 2 Single-Inheritance 3 Virtual Methods ++ Multiple Parents Heap Layout 1 Multiple-Inheritance 2 Virtual Methods 3 ommon Parents Discussion & Learning Outcomes Multiple Inheritance 2 / 44

3 Inheritance Principles 1 Interface Inheritance Outline 2 Implementation Inheritance 3 Liskov Substition Principle and Shapes ++ Object Heap Layout 1 asics 2 Single-Inheritance 3 Virtual Methods ++ Multiple Parents Heap Layout 1 Multiple-Inheritance Excursion: Linearization 1 mbiguous common parents 2 Principles of Linearization 3 Linearization algorithms 2 Virtual Methods 3 ommon Parents Discussion & Learning Outcomes Multiple Inheritance 2 / 44

4 Wouldn t it be nice to inherit from several parents? Multiple Inheritance Inheritance Principles 3 / 44

5 Interface vs. Implementation inheritance The classic motivation for inheritance is implementation inheritance ode reusage hild specializes parents, replacing particular methods with custom ones Parent acts as library of common behaviours Implemented in languages like ++ or Lisp ode sharing in interface inheritance inverts this relation ehaviour contract hild provides methods, with signatures predetermined by the parent Parent acts as generic code frame with room for customization Implemented in languages like Java or # Multiple Inheritance Inheritance Principles 4 / 44

6 Interface Inheritance PowerShovel actuate() FrontLoader actuate() House actuate() ulldozer Undercarriage moveto(x,y) Tracks moveto(x,y) Wheels moveto(x,y) Multiple Inheritance Inheritance Principles 5 / 44

7 Implementation inheritance Ship toot() irport moveto(x,y) shelter(plane) ircraft arrier striket(x,y) Multiple Inheritance Inheritance Principles 6 / 44

8 Excursion: LSP and Square-Rect-Problem The Liskov Substitution Principle Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it. class Rectangle { void setwidth (int w){ this.w=w; } void setheight(int h){ this.h=h; } void getwidth () { return w; } void getheight() { return h; } } class Square extends Rectangle { void setwidth (int w){ this.w=w;h=w; } void setheight(int h){ this.h=h;w=h; } } Rectangle r = new Square(2); r.setwidth(3); r.setheight(4); assert r.getheight()* r.getwidth()==12; Multiple Inheritance Inheritance Principles 7 / 44

9 Excursion: LSP and Square-Rect-Problem The Liskov Substitution Principle Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it. class Rectangle { void setwidth (int w){ this.w=w; } void setheight(int h){ this.h=h; } void getwidth () { return w; } void getheight() { return h; } } class Square extends Rectangle { void setwidth (int w){ this.w=w;h=w; } void setheight(int h){ this.h=h;w=h; } } Rectangle r = new Square(2); r.setwidth(3); r.setheight(4); assert r.getheight()* r.getwidth()==12;! ehavioural assumptions Multiple Inheritance Inheritance Principles 7 / 44

10 So how do we lay out objects in heap anyway? Multiple Inheritance Standard Object Heap Layout 8 / 44

11 Excursion: rief introduction to LLVM IR Low Level Virtual Machine as reference semantics: ;(recursive) struct definitions %struct. = type { i32, %struct., i32(i32)* } %struct. = type { i64, [10 x [20 x i32]], i8 } ;allocation of objects %a = alloca %struct. ;adress computation for selection in structure (pointers): %1 = getelementptr %struct.* %a, i64 0, i64 2 ;load from memory %2 = load i32(i32)* %1 ;indirect call %retval = call i32 (i32)* %2(i32 42) Retrieve the memory layout of a compilation unit with: clang -cc1 -x c++ -v -fdump-record-layouts -emit-llvm source.cpp Retrieve the IR ode of a compilation unit with: clang -O1 -S -emit-llvm source.cpp -o IR.llvm Multiple Inheritance Standard Object Heap Layout Object layout & inheritance 9 / 44

12 Object layout class { int a; int f(int); class : public { int b; int g(int); class : public { int c; int h(int);... c; c.g(42); int a int b int c %class. = type { %class., i32 } %class. = type { %class., i32 } %class. = type { i32 } %c = alloca %class. %1 = bitcast %class.* %c to %class.* %2 = call %1, i32 42) ; g is statically known Multiple Inheritance Standard Object Heap Layout Object layout & inheritance 10 / 44

13 Translation of a method body class { int a; int f(int); class : public { int b; int g(int); class : public { int c; int h(int); int ::g(int p) { return p+b; define %this, i32 %p) { %1 = getelementptr %class.* %this, i64 0, i32 1 %2 = load i32* %1 %3 = add i32 %2, %p ret i32 %3 } Multiple Inheritance Standard Object Heap Layout Object layout & inheritance 11 / 44 int a int b int c %class. = type { %class., i32 } %class. = type { %class., i32 } %class. = type { i32 }

14 Object layout virtual methods class { int a; virtual int f(int); virtual int g(int); virtual int h(int); class : public { int b; int g(int); class : public { int c; int h(int);... c; c.g(42); %c.vptr = bitcast %class.* %c to i32 (%class.*, i32)*** ; vtbl %1 = load (%class.*, i32)*** %c.vptr ; dereference vptr %2 = getelementptr %1, i64 1 ; select g()-entry %3 = load (%class.*, i32)** %2 ; dereference g()-entry %4 = call i32 %3(%class.* %c, i32 42) Multiple Inheritance Standard Object Heap Layout Virtual Methods 12 / 44 vptr int a int b int c ::f ::g ::h %class. = type { %class., i32, [4 x i8] } %class. = type { [12 x i8], i32 } %class. = type { i32 (...)**, i32 }

15 So how do we include several parent objects? Multiple Inheritance Implementation of Multiple inheritance 13 / 44

16 Multiple inheritance class diagram int f(int) int g(int) int a int b int h(int) int c Multiple Inheritance Implementation of Multiple inheritance 14 / 44

17 Static Type asts class { int a; int f(int); class { int b; int g(int); class : public, public { int c; int h(int);... * b = (*) new (); int a int b int c } %class. = type { %class., %class., i32 } %class. = type { i32 } %class. = type { i32 } %1 = call 12) call %1, i8 0, i64 12, i32 4, i1 false) %2 = getelementptr i8* %1, i64 4 ; select -offset in %b = bitcast i8* %2 to %class.* Multiple Inheritance Implementation of Multiple inheritance Multiple base classes in layout 15 / 44

18 Static Type asts class { int a; int f(int); class { int b; int g(int); class : public, public { int c; int h(int);... * b = (*) new (); int a int b int c } %class. = type { %class., %class., i32 } %class. = type { i32 } %class. = type { i32 } %1 = call 12) call %1, i8 0, i64 12, i32 4, i1 false) %2 = getelementptr i8* %1, i64 4 ; select -offset in %b = bitcast i8* %2 to %class.*! implicit casts potentially add a constant to the object pointer. Multiple Inheritance Implementation of Multiple inheritance Multiple base classes in layout 15 / 44

19 Static Type asts class { int a; int f(int); class { int b; int g(int); class : public, public { int c; int h(int);... * b = (*) new (); int a int b int c } %class. = type { %class., %class., i32 } %class. = type { i32 } %class. = type { i32 } %1 = call 12) call %1, i8 0, i64 12, i32 4, i1 false) %2 = getelementptr i8* %1, i64 4 ; select -offset in %b = bitcast i8* %2 to %class.*! implicit casts potentially add a constant to the object pointer.! getelementptr implements as 4 i8! Multiple Inheritance Implementation of Multiple inheritance Multiple base classes in layout 15 / 44

20 Keeping alling onventions class { int a; int f(int); class { int b; int g(int); class : public, public { int c; int h(int);... c; c.g(42); %c = alloca %class. %1 = bitcast %class.* %c to i8* %2 = getelementptr i8* %1, i64 4 ; select -offset in %3 = call %2, i32 42) ; g is statically known int a int b int c } %class. = type { %class., %class., i32 } %class. = type { i32 } %class. = type { i32 } Multiple Inheritance Implementation of Multiple inheritance Multiple base classes in layout 16 / 44

21 mbiguities class { void f(int); class { void f(int); class : public, public { * pc; pc->f(42);! Which method is called? Solution I: Explicit qualification pc->::f(42); pc->::f(42); Solution II: utomagical resolution Idea: The ompiler introduces a linear order on the nodes of the inheritance graph Multiple Inheritance Implementation of Multiple inheritance mbiguities 17 / 44

22 Linearization Principle 1: Inheritance Relation Defined by parent-child. Example: (, ) = Principle 2: Multiplicity Relation Defined by the succession of multiple parents. Example: (, ) = In General: 1 Inheritance is a uniform mechanism, and its searches ( total order) apply identically for all object fields or methods 2 In the literature, we also find the set of constraints to create a linearization as Method Resolution Order 3 Linearization is a best-effort approach at best Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 18 / 44

23 MRO via DFS Leftmost Preorder Depth-First Search W (, ) (W ) (W ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 19 / 44

24 MRO via DFS Leftmost Preorder Depth-First Search L[] = W! Principle 1 inheritance is violated W Python: classical python objects ( 2.1) use LPDFS! LPDFS with Duplicate ancellation (, ) (W ) (W ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 19 / 44

25 MRO via DFS Leftmost Preorder Depth-First Search L[] = W! Principle 1 inheritance is violated W Python: classical python objects ( 2.1) use LPDFS! LPDFS with Duplicate ancellation L[] = W (, ) (W ) (W ) Principle 1 inheritance is fixed V W LPDFS with Duplicate ancellation Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 19 / 44 (, )(V, W )(W, V )

26 MRO via DFS Leftmost Preorder Depth-First Search L[] = W! Principle 1 inheritance is violated W Python: classical python objects ( 2.1) use LPDFS! LPDFS with Duplicate ancellation L[] = W (, ) (W ) (W ) Principle 1 inheritance is fixed Python: new python objects (2.2) use LPDFS(D)! LPDFS with Duplicate ancellation L[] = W V V W! Principle 2 multiplicity not fulfillable! However = W V?? (, )(V, W )(W, V ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 19 / 44

27 MRO via Refined Postorder DFS Reverse Postorder Rightmost DFS F W G D E H (, ) (F, D) (E, H) D(G) E(G) F (W ) G(W ) H(W ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 20 / 44

28 MRO via Refined Postorder DFS Reverse Postorder Rightmost DFS L[] = F D E G H W Linear extension of inheritance relation Topological sorting RPRDFS Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 20 / 44 F W G D E H (, ) (F, D) (E, H) D(G) E(G) F (W ) G(W ) H(W ) F D G E (, ) (F, G) (D, E) D(G) E(F )

29 MRO via Refined Postorder DFS Reverse Postorder Rightmost DFS L[] = F D E G H W Linear extension of inheritance relation Topological sorting RPRDFS L[] = D G E F F W G D E H (, ) (F, D) (E, H) D(G) E(G) F (W ) G(W ) H(W )! ut principle 2 multiplicity is violated! F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 20 / 44

30 MRO via Refined Postorder DFS Reverse Postorder Rightmost DFS L[] = F D E G H W Linear extension of inheritance relation Topological sorting RPRDFS L[] = D G E F F W G D E H (, ) (F, D) (E, H) D(G) E(G) F (W ) G(W ) H(W )! ut principle 2 multiplicity is violated! Refined RPRDFS F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 20 / 44

31 MRO via Refined Postorder DFS Reverse Postorder Rightmost DFS L[] = F D E G H W Linear extension of inheritance relation Topological sorting RPRDFS L[] = D G E F F W G D E H (, ) (F, D) (E, H) D(G) E(G) F (W ) G(W ) H(W )! ut principle 2 multiplicity is violated! LOS: uses Refined RPDFS [3] Refined RPRDFS L[] = D E F G Refine graph with conflict edge & rerun RPRDFS! F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 20 / 44

32 MRO via Refined Postorder DFS Extension Principle: Monotonicity If 1 2 in s linearization, then 1 2 for every linearization of s children. F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 21 / 44

33 MRO via Refined Postorder DFS Refined RPRDFS! Monotonicity is not guaranteed! Extension Principle: Monotonicity If 1 2 in s linearization, then 1 2 for every linearization of s children. F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 21 / 44

34 MRO via Refined Postorder DFS Refined RPRDFS! Monotonicity is not guaranteed! Extension Principle: Monotonicity If 1 2 in s linearization, then 1 2 for every linearization of s children. L[] = D E F G = F G F D G E (, ) (F, G) (D, E) D(G) E(F ) L[] = D G E F = G F Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 21 / 44

35 MRO via 3 Linearization linearization L is an attribute L[] of a class. lasses 1... n are superclasses to child class, defined in the local precedence order ( 1... n ). Then (L i ) = i L[( 1... n )] = (L[ 1 ],..., L[ n ], 1... n ) L[Object] = Object with { c ( i (L i \ c)) if min k j c = head(l k ) / tail(l j )! fail else Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 22 / 44

36 MRO via 3 Linearization L[G] L[F ] L[E(F )] L[D(G)] L[(F, G)] L[(D, E)] L[(, )] G F F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

37 MRO via 3 Linearization L[G] L[F ] L[E(F )] L[D(G)] L[(F, G)] L[(D, E)] L[(, )] G F E F D G F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

38 MRO via 3 Linearization L[G] L[F ] L[E(F )] L[D(G)] L[(F, G)] L[(D, E)] L[(, )] G F E F D G (L[F ] L[G] {F, G}) F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

39 MRO via 3 Linearization L[G] L[F ] L[E(F )] L[D(G)] L[(F, G)] L[(D, E)] L[(, )] G F E F D G ({F } {G} {F, G}) F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

40 MRO via 3 Linearization L[G] L[F ] L[E(F )] L[D(G)] L[(F, G)] L[(D, E)] L[(, )] G F E F D G F G F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

41 MRO via 3 Linearization L[G] G L[F ] F L[E(F )] E F L[D(G)] D G L[(F, G)] F G L[(D, E)] (L[D] L[E] {D, E}) L[(, )] F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

42 MRO via 3 Linearization L[G] G L[F ] F L[E(F )] E F L[D(G)] D G L[(F, G)] F G L[(D, E)] ({D, G} {E, F } {D, E}) L[(, )] F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

43 MRO via 3 Linearization L[G] G L[F ] F L[E(F )] E F L[D(G)] D G L[(F, G)] F G L[(D, E)] D ({G} {E, F } {E}) L[(, )] F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

44 MRO via 3 Linearization L[G] G L[F ] F L[E(F )] E F L[D(G)] D G L[(F, G)] F G L[(D, E)] D G E F L[(, )] F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

45 MRO via 3 Linearization L[G] L[F ] L[E(F )] L[D(G)] L[(F, G)] L[(D, E)] L[(, )] G F E F D G (, ) (F, G) (D, E) D(G) E(F ) F G D G E F ({, F, G} {, D, G, E, F } {, }) F D G E Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

46 MRO via 3 Linearization L[G] G L[F ] F L[E(F )] E F L[D(G)] D G L[(F, G)] F G L[(D, E)] D G E F L[(, )] D ({F, G} {G, E, F }) F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

47 MRO via 3 Linearization L[G] G L[F ] F L[E(F )] E F L[D(G)] D G L[(F, G)] F G L[(D, E)] D G E F L[(, )]! fail F D G E (, ) (F, G) (D, E) D(G) E(F ) Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

48 MRO via 3 Linearization L[G] G L[F ] F L[E(F )] E F L[D(G)] D G L[(F, G)] F G L[(D, E)] D G E F L[(, )]! fail F D G E (, ) (F, G) (D, E) D(G) E(F ) 3 detects and reports a violation of monotonicity with the addition of (,) to the class set. 3 linearization [1]: is used in OpenDylan, Python, and Perl 6 Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 23 / 44

49 Linearization vs. explicit qualification Linearization No switch/duplexer code necessary No explicit naming of qualifiers Unique super reference Reduces number of multi-dispatching conflicts Qualification More flexible, fine-grained Linearization choices may be awkward or unexpected Languages with automatic linearization exist LOS ommon Lisp Object System Dylan, Python and Perl 6 with 3 Prerequisite for Mixins Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 24 / 44

50 nd what about dynamic dispatching in Multiple Inheritance? Multiple Inheritance Implementation of Multiple inheritance Method Resolution Order 25 / 44

51 Virtual Tables for Multiple Inheritance class { int a; virtual int f(int); class { int b; virtual int f(int); virtual int g(int); class : public, public { int c; int f(int);... c; * pb = &c; pb->f(42); ; * pb = &c; %0 = bitcast %class.* %c to i8* ; type fumbling %1 = getelementptr i8* %0, i64 16 ; offset of in %2 = bitcast i8* %1 to %class.* ; get typing right store %class.* %2, %class.** %pb ; store to pb } vptr int a vptr int b int c 0 RTTI ::f RTTI ::f ::g %class. = type { %class., [12 x i8], i32 } %class. = type { i32 (...)**, i32 } %class. = type { i32 (...)**, i32 } Multiple Inheritance Implementation of Multiple inheritance Virtual Table 26 / 44

52 Virtual Tables for Multiple Inheritance class { int a; virtual int f(int); class { int b; virtual int f(int); virtual int g(int); class : public, public { int c; int f(int);... c; * pb = &c; pb->f(42); vptr int a vptr int b int c ; pb->f(42); %0 = load %class.** %pb ;load the b-pointer %1 = bitcast %class.* %0 to i32 (%class.*, i32)*** ;cast to vtable %2 = load i32(%class.*, i32)*** %1 ;load vptr %3 = getelementptr i32 (%class.*, i32)** %2, i64 0 ;select f() entry %4 = load i32(%class.*, i32)** %3 ;load f()-thunk %5 = call i32 %4(%class.* %0, i32 42) } 0 RTTI ::f RTTI ::f ::g %class. = type { %class., [12 x i8], i32 } %class. = type { i32 (...)**, i32 } %class. = type { i32 (...)**, i32 } Multiple Inheritance Implementation of Multiple inheritance Virtual Table 27 / 44

53 asic Virtual Tables ( ++-I) asic Virtual Table consists of different parts: 1 offset to top of an enclosing objects heap representation 2 typeinfo pointer to an RTTI object (not relevant for us) 3 virtual function pointers for resolving virtual methods 0 RTTI ::f RTTI ::f ::g Virtual tables are composed when multiple inheritance is used The vptr fields in objects are pointers to their corresponding virtual-subtables asting preserves the link between an object and its ocrresponding virtual-subtable clang -cc1 -fdump-vtable-layouts -emit-llvm code.cpp yields the vtables of a compilation unit Multiple Inheritance Implementation of Multiple inheritance Virtual Table 28 / 44

54 asting Issues class { int a; class { virtual int f(int); class : public, public { int c; int f(int); * c = new (); c->f(42); * b = new (); b->f(42); 0 RTTI f RTTI f ::f Multiple Inheritance Implementation of Multiple inheritance Virtual Table 29 / 44

55 asting Issues class { int a; class { virtual int f(int); class : public, public { int c; int f(int); * c = new (); c->f(42); 0 RTTI f RTTI f * b = new (); b->f(42);! this-pointer for ::f is expected to point to ::f Multiple Inheritance Implementation of Multiple inheritance Virtual Table 29 / 44

56 asting Issues class { int a; class { virtual int f(int); class : public, public { int c; int f(int); * c = new (); c->f(42); 0 RTTI ::f RTTI ::f ::f * b = new (); b->f(42); ::f! this-pointer for ::f is expected to point to Multiple Inheritance Implementation of Multiple inheritance Virtual Table 29 / 44

57 Thunks Solution: thunks... are trampoline methods, delegating the virtual method to its original implementation with an adapted this-reference define f(%class.* %this, i32 %i) { %1 = bitcast %class.* %this to i8* %2 = getelementptr i8* %1, i64-16 ; sizeof()=16 %3 = bitcast i8* %2 to %class.* %4 = call %3, i32 %i) ret i32 %4 } -in--vtable entry for f(int) is the thunk _f(int) Multiple Inheritance Implementation of Multiple inheritance Virtual Table 30 / 44

58 Thunks Solution: thunks... are trampoline methods, delegating the virtual method to its original implementation with an adapted this-reference define f(%class.* %this, i32 %i) { %1 = bitcast %class.* %this to i8* %2 = getelementptr i8* %1, i64-16 ; sizeof()=16 %3 = bitcast i8* %2 to %class.* %4 = call %3, i32 %i) ret i32 %4 } -in--vtable entry for f(int) is the thunk _f(int) _f(int) adds the statically constant to this before the call to f(int) Multiple Inheritance Implementation of Multiple inheritance Virtual Table 30 / 44

59 Thunks Solution: thunks... are trampoline methods, delegating the virtual method to its original implementation with an adapted this-reference define f(%class.* %this, i32 %i) { %1 = bitcast %class.* %this to i8* %2 = getelementptr i8* %1, i64-16 ; sizeof()=16 %3 = bitcast i8* %2 to %class.* %4 = call %3, i32 %i) ret i32 %4 } -in--vtable entry for f(int) is the thunk _f(int) _f(int) adds the statically constant to this before the call to f(int) f(int) addresses its locals relative to what it assumes to be a pointer Multiple Inheritance Implementation of Multiple inheritance Virtual Table 30 / 44

60 ut what if there are common ancestors? Multiple Inheritance Implementation of Multiple inheritance Virtual Table 31 / 44

61 ommon ases Duplicated ases Standard ++ multiple inheritance conceptually duplicates representations for common ancestors: L int f(int) int l int f(int) int a int f(int) int b int c Multiple Inheritance Implementation of Multiple inheritance Duplicated base classes 32 / 44

62 ommon ases Duplicated ases Standard ++ multiple inheritance conceptually duplicates representations for common ancestors: L int f(int) int l L int f(int) int l int f(int) int a int f(int) int b int c Multiple Inheritance Implementation of Multiple inheritance Duplicated base classes 32 / 44

63 Duplicated ase lasses class L { int l; virtual void f(int); class : public L { int a; void f(int); class : public L { int b; void f(int); class : public, public { int c;... c; L* pl = &c; pl->f(42); * pc = (*)pl; } vptr L int l int a vptr L int l int b int c 0 RTTI ::f RTTI ::f %class. = type { %class., %class., i32, [4 x i8] } %class. = type { [12 x i8], i32 } %class. = type { [12 x i8], i32 } %class.l = type { i32 (...)**, i32 }! mbiguity! L* pl = (*)&c; * pc = (*)(*)pl; Multiple Inheritance Implementation of Multiple inheritance Duplicated base classes 33 / 44

64 ommon ases Shared ase lass Optionally, ++ multiple inheritance enables a shared representation for common ancestors, creating the diamond pattern: W int f(int) int g(int) int h(int) int w virtual virtual int f(int) int a int g(int) int b int h(int) int c Multiple Inheritance Implementation of Multiple inheritance ommon base classes 34 / 44

65 Shared ase lass class W { int w; virtual void f(int); virtual void g(int); virtual void h(int); class : public virtual W { int a; void f(int); class : public virtual W { int b; void g(int); class : public, public { int c; void h(int);... * pc; pc->f(42); ((W*)pc)->h(42); ((*)pc)->f(42); vptr int a vptr int b int c vptr W int w W 0 RTTI ::f ::h W- RTTI ::g W RTTI ::Wf ::Wg ::Wh! Offsets to virtual base! mbiguities e.g. overwriting f in and Multiple Inheritance Implementation of Multiple inheritance ommon base classes 35 / 44

66 Dynamic Type asts class : public virtual W {... class : public virtual W {... class : public, public {... class D : public, public { c; W* pw = &c; * pc = (*)pw; // ompile error vs. * pc = dynamic_cast<*>(pw); W vptr int a vptr int b int c vptr int w vptr int a vptr int b int c vptr int b D int d vptr W int w Multiple Inheritance Implementation of Multiple inheritance ommon base classes 36 / 44

67 Dynamic Type asts class : public virtual W {... class : public virtual W {... class : public, public {... class D : public, public { c; W* pw = &c; * pc = (*)pw; // ompile error vs. * pc = dynamic_cast<*>(pw); W vptr int a vptr int b int c vptr int w vptr int a vptr int b int c vptr int b D int d vptr W int w! No guaranteed constant offsets between virtual bases and subclasses No static casting! Multiple Inheritance Implementation of Multiple inheritance ommon base classes 36 / 44

68 Dynamic Type asts class : public virtual W {... class : public virtual W {... class : public, public {... class D : public, public { c; W* pw = &c; * pc = (*)pw; // ompile error vs. * pc = dynamic_cast<*>(pw); W vptr int a vptr int b int c vptr int w vptr int a vptr int b int c vptr int b D int d vptr W int w! No guaranteed constant offsets between virtual bases and subclasses No static casting!! Dynamic casting makes use of offset-to-top Multiple Inheritance Implementation of Multiple inheritance ommon base classes 36 / 44

69 gain: asting Issues class W { virtual int f(int); class : virtual W { int a; class : virtual W { int b; class : public, public { int c; int f(int); * b = new (); b->f(42); vptr RTTI ::f ::f? { W RTTI ::Wf ::f W* w = new (); w->f(42); vptr ::Wf Multiple Inheritance Implementation of Multiple inheritance ommon base classes 37 / 44

70 gain: asting Issues class W { virtual int f(int); class : virtual W { int a; class : virtual W { int b; class : public, public { int c; int f(int); * b = new (); b->f(42); vptr RTTI ::f ::f? { W RTTI ::Wf ::f W* w = new (); w->f(42); vptr ::Wf! In a conventional thunk ::f adjusts the this-pointer with a statically known constant to point to Multiple Inheritance Implementation of Multiple inheritance ommon base classes 37 / 44

71 Virtual Thunks class W {... virtual void g(int); class : public virtual W {... class : public virtual W { int b; void g(int i){ class : public,public {... c; W* pw = &c; pw->g(42); Multiple Inheritance Implementation of Multiple inheritance ommon base classes 38 / 44 vptr int a vptr int b int c vptr W int w define g(%class.* %this, i32 %i) { ; virtual thunk to ::g %1 = bitcast %class.* %this to i8* %2 = bitcast i8* %1 to i8** %3 = load i8** %2 ; load W-vtable ptr %4 = getelementptr i8* %3, i64-32 ; -32 bytes is g-entry in vcalls %5 = bitcast i8* %4 to i64* %6 = load i64* %5 ; load g s vcall offset %7 = getelementptr i8* %1, i64 %6 ; navigate to vcalloffset+ Wtop %8 = bitcast i8* %7 to %class.* call %8, i32 %i) ret void } W 0 RTTI ::f ::h W- RTTI ::g W- W- W- W RTTI ::Wf ::Wg ::Wh

72 Virtual Tables for Virtual ases ( ++-I) Virtual Table for a Virtual Subclass gets a virtual base pointer Virtual Table for a Virtual ase consists of different parts: 1 virtual call offsets per virtual function for adjusting this dynamically 2 offset to top of an enclosing objects heap representation 3 typeinfo pointer to an RTTI object (not relevant for us) 4 virtual function pointers for resolving virtual methods Virtual ase classes have virtual thunks which look up the offset to adjust the this pointer to the correct value in the virtual table! W- RTTI ::g W- W- W- W RTTI ::Wf ::Wg ::Wh Multiple Inheritance Implementation of Multiple inheritance ommon base classes 39 / 44

73 ompiler and Runtime ollaboration ompiler generates: 1... one code block for each method 2... one virtual table for each class-composition, with references to the most recent implementations of methods of a unique common signature ( single dispatching) sub-tables for the composed subclasses static top-of-object and virtual bases offsets per sub-table (virtual) thunks as this-adapters per method and subclass if needed Runtime: 1 t program startup virtual tables are globally created 2 llocation of memory space for each object followed by constructor calls 3 onstructor stores pointers to virtual table (or fragments) in the objects 4 Method calls transparently call methods statically or from virtual tables, unaware of real class identity 5 Dynamic casts may use offset-to-top field in objects Multiple Inheritance Implementation of Multiple inheritance ompiler and Runtime ollaboration 40 / 44

74 Polemics of Multiple Inheritance Full Multiple Inheritance (FMI) Removes constraints on parents in inheritance More convenient and simple in the common cases Occurance of diamond pattern not as frequent as discussions indicate Multiple Interface Inheritance (MII) simpler implementation Interfaces and aggregation already quite expressive Too frequent use of FMI considered as flaw in the class hierarchy design Multiple Inheritance Discussion 41 / 44

75 Lessons Learned Lessons Learned 1 Different purposes of inheritance 2 Heap Layouts of hierarchically constructed objects in ++ 3 Virtual Table layout 4 LLVM IR representation of object access code 5 Linearization as alternative to explicit disambiguation 6 Pitfalls of Multiple Inheritance Multiple Inheritance Discussion 42 / 44

76 Sidenote for MS V++ the presented approach is implemented in GNU ++ and LLVM Microsoft s MS V++ approaches multiple inheritance differently splits the virtual table into several smaller tables keeps a vbptr (virtual base pointer) in the object representation, pointing to the virtual base of a subclass. Multiple Inheritance Discussion 43 / 44

77 Further reading... K. arrett,. assels, P. Haahr, D. Moon, K. Playford, and T. Withington. monotonic superclass linearization for dylan. In Object Oriented Programming Systems, Languages, and pplications, odesourcery, ompaq, EDG, HP, IM, Intel, R. Hat, and SGI. Itanium ++ I. URL: R. Ducournau and M. Habib. On some algorithms for multiple inheritance in object-oriented programming. In Proceedings of the European onference on Object-Oriented Programming (EOOP), R. Kleckner. ringing clang and llvm to visual c++ users. URL: Liskov. Keynote address data abstraction and hierarchy. In ddendum to the proceedings on Object-oriented programming systems, languages and applications, OOPSL 87, pages 17 34, L. L. R. Manual. Llvm project. URL: R. Multiple. Martin. Inheritance Further materials 44 / 44