Delphi interface mechanism--compiler implementation process of interface operation (2)

Memory space for Interface objects

Suppose we define the following two interfaces Iintfa and IINTFB, where Proca and PROCB will be implemented as static methods, and Virta and VIRTB will be implemented as virtual methods:

[Delphi]View Plaincopyprint?

1. IINTFA = Interface
2. procedure Proca;
3. procedure Virta;
4. end;
6. IINTFB = Interface
7. procedure PROCB;
8. procedure VIRTB;
9. end;

Then we define a Tmyobject class, which inherits from Tinterfacedobject and implements IINTFA and IINTFB two interfaces:

[Delphi]View Plaincopyprint?

1. Tmyobject = Class (Tinterfacedobject, IINTFA, IINTFB)
2. Ffielda:integer;
3. Ffieldb:integer;
4. procedure Proca;
5. procedure Virta; virtual;
6. procedure PROCB;
7. procedure VIRTB; virtual;
8. end;

Then we execute the following code:

[Delphi]View Plaincopyprint?

2. Var
4. Myobject:tmyobject;
6. Myintf:iinterface;
8. MYINTFA:IINTFA;
10. MYINTFB:IINTFB;
12. begin
14. MyObject: = Tmyobject.  Create; //Create Tmyobject object
16. myintf: = MyObject; //To point the interface to the MyObject object
18. MYINTFA: = MyObject;
20. MYINTFB: = MyObject;
22. end;

During the execution of the above code, the compiler implements the memory space diagram as follows:

Look at the leftmost column first. MyObject is an object pointer to a 0 offset (virtual method table pointer) in the object's data space. You can see that MYINTF/MYINTFA/MYINTFB three interfaces are implemented as pointers, and these three pointers point to an area of 4 bytes in MyObject object data space, respectively.
The middle column is the object memory space. As you can see, there are three additional fields in the object memory space of Tmyobject compared to objects that do not support interfaces: IINTERFACE/IINTFB/IINTFA. These fields are also pointers, pointing to the memory address of the interface jump table. Note that the order of MYINTFA/MYINTFB is the opposite of the order of Tmyobject class declarations, why?
The third column is the virtual method table for the class, consistent with the generic class (the class that does not support the interface).
-----------
Interface Jump Table
-----------
An interface jump table is a row of function pointers to the function addresses that implement the current interface, arranged in the order in which they are declared in the interface. Now let's look at what the so-called "interface Jump Table" is for.
We know that when an object calls a member function of a class, such as executing Myobject.proca, it implicitly passes a self pointer to the member function: Myobject.proca (self). Self is the address of the object data space. So how does the compiler know the self pointer? The original object pointer MyObject point to the address is self, the compiler directly remove the myobject^ can be used as self.
When invoking member functions as an interface, such as Myintfa.proca, the compiler does not know what type of object MYINTFA is pointing to (class), and does not know the distance between MYINTFA and self (in fact, in the example above, Delphi The compiler knows the distance between MYINTFA and self, just to be compatible with COM's binary format, so that other languages can also invoke interface member functions using interface pointers, which must be corrected with the later self pointer, and the compiler directly sets the address that MYINTFA points to self. As you can see, MYINTFA points to the $18 offset address in the MyObject object space. The self pointer is, of course, wrong, and the compiler cannot call Tmyobject.proca directly, but instead calls Proca in IINTFA's Interface jump table. The content of the Proca in the interface jump table is to fix the self pointer (self-$18) and then call Tmyobject.proca, which is the correct invocation of the object's member function. Because each class implements an interface in a different order, there are different interface jump tables for the same interface to be implemented in separate classes (of course, the editor can intelligently check that some classes have an "interface jump table" offset of the same or shared use).
This is the compiler implementation process, using the "Interface Jump table" is the real reason is that interface must support the COM binary format standard. is a COM binary specifications excerpt from the Learning Notes of 〈com principles and applications:

----------------------------------------
Initialization of interface jump pointers in object memory space
----------------------------------------
Another problem is how the interface jump pointers in the object memory space are initialized. Originally, in Tobject.initinstance, after clearing 0 object memory space with Fillchar, the work is to initialize the object's interface jump pointer:

[Delphi]View Plaincopyprint?

2. function TObject.  InitInstance (instance:pointer): TObject;
4. Var
6. intftable:pinterfacetable;
8. Classptr:tclass;
10. I:integer;
12. begin
14. Fillchar (instance^, Instancesize, 0);
16. Pinteger (Instance) ^: = Integer (self);
18. Classptr: = self;
20. While classptr <> nil do
22. begin
24. Intftable: = Classptr.  getinterfacetable;
26. if intftable <> nil Then
28. For I: = 0 to intftable. entrycount-1 do
30. With intftable. Entries[i] do
32. begin
34. if VTable <> nil Then
36. Pinteger (@PChar (Instance) [Ioffset]) ^: = Integer (VTable);
38. end;
40. Classptr: = Classptr.  Classparent;
42. end;
44. Result: = Instance;
46. end;

----------------------
The realization of implements
----------------------
Delphi can use the Implements keyword to delegate an interface method to another interface or object. The following tmyobject as the base class, to examine the implementation of the Implements method.

[Delphi]View Plaincopyprint?

1. tmyobject = class ( TINTERFACEDOBJECT,&NBSP;IINTFA,&NBSP;IINTFB)   
2.     FFieldA:  integer;  
3. &NBSP;&NBSP;&NBSP;&NBSP;FFIELDB:&NBSP;INTEGER;&NBSP;&NBSP;
4.     procedure proca;  
5. procedure virta; virtual;  
6.     procedure procb;  
7. procedure virtb; virtual;  
8.     DESTRUCTOR&NBSP;DESTROY;&NBSP;OVERRIDE;&NBSP;&NBSP;
Li class= "alt" >   end;  

(1) Implement implements with interface member variables

[Delphi]View Plaincopyprint?

1. TMyObject2 = Class (Tinterfacedobject, IINTFA)
2. FINTFA:IINTFA;
3. Property INTFA:IINTFA read FINTFA implements IINTFA;
4. End

At this point the implementation of the compiler is very simple, because FINTFA is the interface pointer, if you use the interface assignment MYINTFA: = MyObject2 Such a statement invocation, MYINTFA directly points to MYOBJECT2.FINTFA.

(2) Implement implements with object member variables

In the following example, if an interface class TMyObject3 implements implements as an object (which is usually the case), its object memory space is arranged in almost the same way as the Tmyobject memory space:

[Delphi]View Plaincopyprint?

1. TMYOBJECT3 = Class (Tinterfacedobject, IINTFA, IINTFB)
2. Fmyobject:tmyobject;
3. function Getmyobject:tmyobject;
4. Property Myobject:tmyobject Read Getmyobject implements IINTFA, IINTFB;
5. end;

The difference is that the content of the TMyObject3 "interface Jump table" has changed. Since TMYOBJECT3 does not implement IINTFA and IINTFB on its own, it is the Fmyobject object that implements both interfaces. At this point, the method called in the interface jump table must be changed to the method that calls the Fmyobject object. For example, the following code:

[Delphi]View Plaincopyprint?

2. Var
4. MYOBJECT3:TMYOBJECT3;
6. MYINTFA:IINTFA;
8. begin
10. myobject3:= TMyObject3.  Create;
12. MyObject3. Fmyobject: = Tmyobject.  Create;
14. MYINTFA: = MyObject3;
16. MYINTFA. _addref;
18. MYINTFA.  Proca;
20. MYINTFA. _release;
22. end;

When executing the MYINTFA._ADDREF statement, the compiler generates an "interface Jump" code:

[Delphi]View Plaincopyprint?

2. {myintfa._addref;}
4. mov eax,[ebp-$0c] //eax = myintfa^
6. push eax //myintfa^ set to self
8. MOV Eax,[eax] //eax = interface Jump table address pointer
10. Call DWORD ptr [eax+$04] //Go to Interface jump table
14. {The code in the "Interface Jump segment"}
16. mov eax,[esp+$04] //[esp+$04] is the interface pointer content (myintfa^)
18. Add eax,-$14 //fix eax = self (MyObject2)
20. Call TMyObject2. Getmyobject
22. mov [esp+$04],eax //Get Fmyobject object, note [esp+$04]
24. JMP tinterfacedobject. _addref //Call Fmyobject._addref

[Esp+$04] is a notable place. Only one parameter, self, is fixed in the interface jump table, and the other invocation parameters, if any, are set by the compiler before the execution enters the interface jump table. Here _addref is using the stdcall calling convention, so esp+$04 is self. As mentioned earlier, the compiler directly takes the contents of the interface pointer as the self parameter, and then goes to the "interface jump table" to fix the self, before invoking the object method. The assembly code above is the method of correcting self to fmyobject and calling Fmyobject.
You can see that the Fmyobject._addref method increases the reference count of the Fmyobject object, and it seems that the implementation of implements simply transmits the interface to the object execution, and other methods must be used to implement the COM component aggregation.

http://blog.csdn.net/tht2009/article/details/6768032

Delphi interface mechanism--compiler implementation process of interface operation (2)