Delphi的对象机制浅探
savetime2k@yahoo.com
2004-1-3
前几天开始阅读 VCL 源代码,可是几个基类的继承代码把我看得头大。在大富翁请教了几位仁兄后,我还是对Delphi对象的创建和方法调用原理不太清楚。最后只好临时啃了一下汇编,把Delphi对象操作的几个关键的方法勘察了一遍。
你可以通过以下链接知道我为什么要做这件事:
http://www.delphibbs.com/delphibbs/dispq.asp?lid=2385681
这是我花费一个晚上的测试结果,更多的细节只能以后在学习中再去了解。
主要测试项目为:
⊙ 测试目标:查看 TObject.Create 的编译器实现
⊙ 测试目标:查看 constructor 函数中 inherited 的编译器实现
⊙ 测试目标:以 object reference 和 class reference 调用构造函数的编译器实现
⊙ 测试目标:考查 Object 和 Class 在调用 class method 时的编译器实现
⊙ 测试目标:考查 ShortString 返回值类型的函数没有赋值时编译器的实现
我把测试的细节记录在后文,一是自己留作参考,二是给对此有兴趣的朋友参考。其实更重要的是,大家可以帮忙检查我的分析有没有错误。我一直是用 Delphi 的组件拖放编程,真正的功底只是这几天阅读 Object Pascal Reference 和 VCL 得来的,汇编更是临时抱佛脚,所以错误难免。我清楚自己的水平,所以写下结论后非常担心。尽管如此,我的目的是为了学习,希望你发现错误后帮我指出来。
主要的结论是:
(*) TObject.Create确实是个空函数,Borland 并没有隐藏 TObject.Create 的代码。TObject.Create的汇编代码是由 constructor directive 指示编译器形成的,编译器对每个class 都一视同仁。
(*) dl 和 eax 是 constructor Create 实现的关键寄存器。Borland 将对象的创建过程设计得精妙而清晰(个人感觉,因为我不知道其他的语言比如C++是如何实现的)。
(*) 一个对象的正常的创建(Obj := TMyClass.Create)过程是这样的:
1. 编译器保证第一个 constructor 调用之前 dl = 1
编译器保证 inherited Create 调用之前 dl = 0
2. dl = 1 时 编译器保证 Create 时 eax = pointer to class VMT
dl = 0 时 编译器保证 Create 时 eax = pointer to current object
3. 编译器保证任何层次的 constructor 调用后 eax = pointer to current object
4. dl = 1 时 编译器保证 Create 调用 System._ClassCreate,并与 constructor 相同的方式使用 eax
dl = 1 时 编译器保证 Create 调用 System._AfterConstruction,并且调用前后 eax = pointer to current object
dl = 0 时 编译器保证 Create 不会调用 System._ClassCreate
dl = 0 时 编译器保证 Create 不会调用 System._AfterConstruction
5. System._ClassCreate 中设置结构化异常处理,在 Create 即将结束时关闭结构化异常处理。
如果出错则会(1)释放由编译器分配的内存(2)恢复堆栈至创建对象之前(3)调用 TSomeClass.Destroy。
(*) object reference 方式的 constructor 调用,编译器尝试实现为 inherited 调用,结果当然是错误。
(*) class method 的调用隐含参数 eax 为指向 VMT 的指针,不管是用 class 还是 object 方式调用,编译器都会正确地把指向 class VMT 的指针传递给 eax。
要读懂下文的测试过程,可能需要相关基础,推荐阅读 Object Pascal Reference 以下章节:
Parameter passing
Function results
Calling conventions (register缺省调用约定,constructor 和 destructor 函数必须采用 register 约定)
Inline assambly code
《Delphi的原子世界》非常值得一读。
以下是测试内容:
=================================================
⊙ 测试目标:查看 TObject.Create 的编译器实现
=================================================
⊙ 测试代码及反汇编代码:
procedure Test; register;
var
Obj: TObject;
begin
push ebp ; 前2句用于设置堆栈指针
mov ebp, esp
push ecx ; 保存 ecx (无用的语句)
Obj := TObject.Create;
mov dl, $01 ; 设置 dl = 1,通知 TObject.Create 这是一次新建对象的调用
mov eax, [$004010a0] ; 把指向 TObject class VMT 的指针存入 eax,
; 作为 TObject.Create 隐含的 Self 参数
call TObject.Create ; 调用 TObject.Create 函数
mov [ebp-$04], eax ; TObject.Create 返回新建对象的指针至 Obj
end;
pop ecx ; 恢复堆栈并返回
pop ebp
ret
⊙ TObject.Create 的反汇编代码:
; 函数进入时 eax = pointer to VMT (dl = 1)
eax = pointer to instance (dl = 0)
; 函数返回时 eax = pointer to instance
test dl, dl ; 检查 dl 是否 = 0
jz +$08 ; dl = 0则跳至 @@1
add esp, -$10 ; 增加 16 字节的堆栈,每次调用 _ClassCreate 之前都会进行
; 用于 System._ClassCreate 设置结构化异常处理
call @ClassCreate ; 调用 System._ClassCreate
@@1:
test dl, dl ; 检查 dl 是否 = 0
jz +$0f ; dl = 0则跳到 end 结束过程
call @AfterConstruction ; dl <> 0 则调用 System._AfterConstruction
; (注意不是 TObject.AfterConstruction)
pop dword ptr fs:[$00000000] ; fs:[0] 指向结构化异常处理的函数,此即取消最后一次的 try..except设置
; 这个 try..except 在 System._ClassCreate 中创建
; 用于在出错时自动恢复堆栈/释放内存分配/并调用 TObject.Free
add esp, $0c ; 恢复堆栈,注意只恢复了 12 字节的堆栈,还有4字节由上句 pop 了
ret
注意:以上汇编代码中重复出现了 test dl,dl,说明 Borland 并没有特别对待 TObject.Create,TObject.Create确实是个空函数。TObject.Create的汇编代码是由 constructor directive 指示编译器形成的,编译器对每个class 都一视同仁。
注意:这段 TObject.Create 代码是在 PC 机上编译的结果,严格地说应该是在 Win32 操作系统上的实现之一。查看System._ClassCreate 就知道 Borland 还有其他的异常处理实现机制,产生的 TObject.Create 代码也不相同。
⊙ System._AfterContruction 函数的代码:
function _AfterConstruction(Instance: TObject): TObject;
begin
Instance.AfterConstruction;
Result := Instance;
end;
⊙ System._ClassCreate 函数的代码:
function _ClassCreate(AClass: TClass; Alloc: Boolean): TObject;
asm
{ -> EAX = pointer to VMT }
{ <- EAX = pointer to instance }
PUSH EDX ; 保存寄存器
PUSH ECX
PUSH EBX
TEST DL,DL ; 如果 dl = 0 则不调用 TObject.NewInstance
JL @@noAlloc
CALL DWORD PTR [EAX] + VMTOFFSET TObject.NewInstance ; 调用 TObject.NewInstance
@@noAlloc:
{$IFNDEF PC_MAPPED_EXCEPTIONS} ; 设置 PC 架构的结构化异常处理
XOR EDX,EDX
LEA ECX,[ESP+16]
MOV EBX,FS:[EDX]
MOV [ECX].TExcFrame.next,EBX
MOV [ECX].TExcFrame.hEBP,EBP
MOV [ECX].TExcFrame.desc,offset @desc
MOV [ECX].TexcFrame.ConstructedObject,EAX { trick: remember copy to instance }
MOV FS:[EDX],ECX
{$ENDIF}
POP EBX ; 恢复寄存器
POP ECX
POP EDX
RET
{$IFNDEF PC_MAPPED_EXCEPTIONS} ; 设置非 PC 架构的结构化异常处理
@desc:
JMP _HandleAnyException
{ destroy the object }
MOV EAX,[ESP+8+9*4]
MOV EAX,[EAX].TExcFrame.ConstructedObject
TEST EAX,EAX
JE @@skip
MOV ECX,[EAX]
MOV DL,$81
PUSH EAX
CALL DWORD PTR [ECX] + VMTOFFSET TObject.Destroy
POP EAX
CALL _ClassDestroy
@@skip:
{ reraise the exception }
CALL _RaiseAgain
{$ENDIF}
end;
==============================================================
⊙ 测试目标:查看 constructor 函数中 inherited 的编译器实现
==============================================================
⊙ 测试代码及反汇编代码:
type
TMyClass = class(TObject)
constructor Create;
end;
constructor TMyClass.Create;
begin
inherited; // 考查此句的实现
Beep;
end;
procedure Test; register;
var
Obj: TMyClass;
begin
Obj := TMyClass.Create;
mov dl, $01 ; class reference 时编译器设置 dl = 1
mov eax, [$004600ec] ; 设置 eax 为指向 TMyClass 的 VMT pointer
call TMyClass.Create ; 调用 TMyClass.Create
mov [ebp-$04], eax ; 保存 新建对象的指针
end;
constructor TMyClass.Create 的反汇编代码:
; 函数进入时 eax = pointer to VMT (dl = 1)
eax = pointer to instance (dl = 0)
; 函数返回时 eax = pointer to instance
begin
push ebp ; 这3句用于保存堆栈指针和创建堆栈
mov ebp, esp
add esp, -$08
test dl, dl ; 如果 dl = 0 则跳到 @ClassCreate 之后 @@1 处执行
jz +$08
add esp, -$10 ; 为 _ClassCreate 调用准备堆栈
call @ClassCreate ; 调用 System._ClassCreate,执行完成后 eax = 新建对象的指针
@@1:
mov [ebp-$05], dl ; 将 dl 值保存到堆栈中的 1 字节中,因为后面的 inherited TObject.Create
; 可能会改变 edx 的值
mov [ebp-$04], eax ; 保存 eax 到堆栈, eax = pointer to instance
inherited;
xor edx, edx ; 将 edx 清零(dl = 0),以通知 TObject.Create 不用再调用
; _ClassCreate 和 AfterConstructor (编译器实现)
mov eax, [ebp-$04] ; 将 eax 的值还原为前面保存在堆栈的 eax 值
; (这句是多余的,但在其它情况下可能必须执行此句)
call TObject.Create ; 调用 TObject.Create
Beep;
call Beep ; 继承类中 inherited 之后实现的功能
mov eax, [ebp-$04] ; 将 eax 的值还原为前面保存在堆栈的 eax 值
cmp byte ptr [ebp-$05], $00 ; (间接)检查 dl 是否 = 0
jz +$0f ; dl = 0 则跳过 _AfterConstruction 到 @@2 处
call @AfterConstruction ; 调用 System._AfterConstruction
pop dword ptr fs:[$00000000] ; 这2句恢复为 _ClassCreate 创建的堆栈空间
add esp, $0c
@@2:
mov eax, [ebp-$04] ; 返回 pointer to instance
end;
pop ecx
pop ecx
pop ebp
ret
结论:真是精妙!一个对象的正常的创建(Obj := TMyObj.Create, 与后面不正常的调用相对)过程是这样的:
1. 编译器保证第一个 constructor 调用之前 dl = 1
编译器保证 inherited Create 调用之前 dl = 0
2. dl = 1 时 编译器保证 Create 时 eax = pointer to class VMT
dl = 0 时 编译器保证 Create 时 eax = pointer to current object
3. 编译器保证任何层次的 constructor 调用后 eax = pointer to current object
4. dl = 1 时 编译器保证 Create 调用 System._ClassCreate,并与 constructor 相同的方式使用 eax
dl = 1 时 编译器保证 Create 调用 System._AfterConstruction,并且调用前后 eax = pointer to current object
dl = 0 时 编译器保证 Create 不会调用 System._ClassCreate
dl = 0 时 编译器保证 Create 不会调用 System._AfterConstruction
5. System._ClassCreate 中设置结构化异常处理,在 Create 即将结束时关闭结构化异常处理。
如果出错则会(1)释放由编译器分配的内存(2)恢复堆栈至创建对象之前(3)调用 TSomeClass.Destroy。
看上去有点繁杂,可是如果读懂了上面 TObject.Create 和 TMyObject.Create 则会感觉对象的创建非常清晰。
==================================================================================
⊙ 测试目标:以 object reference 和 class reference 调用构造函数的编译器实现
==================================================================================
⊙ static constructor 测试代码及反汇编代码 (省略了begin 和 end 后面的堆栈分配代码):
procedure Test; register;
var
Obj: TObject;
begin
Obj := TObject.Create;
mov dl, $01 ; 采用 class reference 时编译器自动设置 dl = 1
mov eax, [$004010a0] ; 把指向 TObject class VMT 的指针存入 eax,用于下一行调用
call TObject.Create
mov [ebp-$04], eax
Obj := Obj.Create;
or edx, -$01 ; 采用 object reference 时编译器自动设置 edx 的所有 bit 都为 1
mov eax, [ebp-$04] ; 把 Obj 指针的所指的区域(即对象内存空间)存入 eax,用于下一行调用
call TObject.Create
mov [ebp-$04], eax
end;
⊙ virtual constructor测试代码及反汇编代码 (省略了begin 和 end 后面的堆栈分配代码):
procedure Test; register;
var
Comp: TComponent;
begin
Comp := TComponent.Create(nil);
xor ecx, ecx ; 设置 参数 = nil
mov dl, $01 ; 设置 dl = 1
mov eax, [$00412eac] ; 设置 eax = class VMT pointer
call TComponent.Create ; 调用 TComponent.Create
mov [ebp-$04], eax ; 保存 新建的对象至 Comp
Comp := Comp.Create(nil);
xor ecx, ecx ; 同上
or edx, -$01 ; 设置 edx 所有位为 1
mov eax, [ebp-$04] ; 这句和下句 设置 ebx 为 TComponent cl
savetime2k@yahoo.com
2004-1-3
前几天开始阅读 VCL 源代码,可是几个基类的继承代码把我看得头大。在大富翁请教了几位仁兄后,我还是对Delphi对象的创建和方法调用原理不太清楚。最后只好临时啃了一下汇编,把Delphi对象操作的几个关键的方法勘察了一遍。
你可以通过以下链接知道我为什么要做这件事:
http://www.delphibbs.com/delphibbs/dispq.asp?lid=2385681
这是我花费一个晚上的测试结果,更多的细节只能以后在学习中再去了解。
主要测试项目为:
⊙ 测试目标:查看 TObject.Create 的编译器实现
⊙ 测试目标:查看 constructor 函数中 inherited 的编译器实现
⊙ 测试目标:以 object reference 和 class reference 调用构造函数的编译器实现
⊙ 测试目标:考查 Object 和 Class 在调用 class method 时的编译器实现
⊙ 测试目标:考查 ShortString 返回值类型的函数没有赋值时编译器的实现
我把测试的细节记录在后文,一是自己留作参考,二是给对此有兴趣的朋友参考。其实更重要的是,大家可以帮忙检查我的分析有没有错误。我一直是用 Delphi 的组件拖放编程,真正的功底只是这几天阅读 Object Pascal Reference 和 VCL 得来的,汇编更是临时抱佛脚,所以错误难免。我清楚自己的水平,所以写下结论后非常担心。尽管如此,我的目的是为了学习,希望你发现错误后帮我指出来。
主要的结论是:
(*) TObject.Create确实是个空函数,Borland 并没有隐藏 TObject.Create 的代码。TObject.Create的汇编代码是由 constructor directive 指示编译器形成的,编译器对每个class 都一视同仁。
(*) dl 和 eax 是 constructor Create 实现的关键寄存器。Borland 将对象的创建过程设计得精妙而清晰(个人感觉,因为我不知道其他的语言比如C++是如何实现的)。
(*) 一个对象的正常的创建(Obj := TMyClass.Create)过程是这样的:
1. 编译器保证第一个 constructor 调用之前 dl = 1
编译器保证 inherited Create 调用之前 dl = 0
2. dl = 1 时 编译器保证 Create 时 eax = pointer to class VMT
dl = 0 时 编译器保证 Create 时 eax = pointer to current object
3. 编译器保证任何层次的 constructor 调用后 eax = pointer to current object
4. dl = 1 时 编译器保证 Create 调用 System._ClassCreate,并与 constructor 相同的方式使用 eax
dl = 1 时 编译器保证 Create 调用 System._AfterConstruction,并且调用前后 eax = pointer to current object
dl = 0 时 编译器保证 Create 不会调用 System._ClassCreate
dl = 0 时 编译器保证 Create 不会调用 System._AfterConstruction
5. System._ClassCreate 中设置结构化异常处理,在 Create 即将结束时关闭结构化异常处理。
如果出错则会(1)释放由编译器分配的内存(2)恢复堆栈至创建对象之前(3)调用 TSomeClass.Destroy。
(*) object reference 方式的 constructor 调用,编译器尝试实现为 inherited 调用,结果当然是错误。
(*) class method 的调用隐含参数 eax 为指向 VMT 的指针,不管是用 class 还是 object 方式调用,编译器都会正确地把指向 class VMT 的指针传递给 eax。
要读懂下文的测试过程,可能需要相关基础,推荐阅读 Object Pascal Reference 以下章节:
Parameter passing
Function results
Calling conventions (register缺省调用约定,constructor 和 destructor 函数必须采用 register 约定)
Inline assambly code
《Delphi的原子世界》非常值得一读。
以下是测试内容:
=================================================
⊙ 测试目标:查看 TObject.Create 的编译器实现
=================================================
⊙ 测试代码及反汇编代码:
procedure Test; register;
var
Obj: TObject;
begin
push ebp ; 前2句用于设置堆栈指针
mov ebp, esp
push ecx ; 保存 ecx (无用的语句)
Obj := TObject.Create;
mov dl, $01 ; 设置 dl = 1,通知 TObject.Create 这是一次新建对象的调用
mov eax, [$004010a0] ; 把指向 TObject class VMT 的指针存入 eax,
; 作为 TObject.Create 隐含的 Self 参数
call TObject.Create ; 调用 TObject.Create 函数
mov [ebp-$04], eax ; TObject.Create 返回新建对象的指针至 Obj
end;
pop ecx ; 恢复堆栈并返回
pop ebp
ret
⊙ TObject.Create 的反汇编代码:
; 函数进入时 eax = pointer to VMT (dl = 1)
eax = pointer to instance (dl = 0)
; 函数返回时 eax = pointer to instance
test dl, dl ; 检查 dl 是否 = 0
jz +$08 ; dl = 0则跳至 @@1
add esp, -$10 ; 增加 16 字节的堆栈,每次调用 _ClassCreate 之前都会进行
; 用于 System._ClassCreate 设置结构化异常处理
call @ClassCreate ; 调用 System._ClassCreate
@@1:
test dl, dl ; 检查 dl 是否 = 0
jz +$0f ; dl = 0则跳到 end 结束过程
call @AfterConstruction ; dl <> 0 则调用 System._AfterConstruction
; (注意不是 TObject.AfterConstruction)
pop dword ptr fs:[$00000000] ; fs:[0] 指向结构化异常处理的函数,此即取消最后一次的 try..except设置
; 这个 try..except 在 System._ClassCreate 中创建
; 用于在出错时自动恢复堆栈/释放内存分配/并调用 TObject.Free
add esp, $0c ; 恢复堆栈,注意只恢复了 12 字节的堆栈,还有4字节由上句 pop 了
ret
注意:以上汇编代码中重复出现了 test dl,dl,说明 Borland 并没有特别对待 TObject.Create,TObject.Create确实是个空函数。TObject.Create的汇编代码是由 constructor directive 指示编译器形成的,编译器对每个class 都一视同仁。
注意:这段 TObject.Create 代码是在 PC 机上编译的结果,严格地说应该是在 Win32 操作系统上的实现之一。查看System._ClassCreate 就知道 Borland 还有其他的异常处理实现机制,产生的 TObject.Create 代码也不相同。
⊙ System._AfterContruction 函数的代码:
function _AfterConstruction(Instance: TObject): TObject;
begin
Instance.AfterConstruction;
Result := Instance;
end;
⊙ System._ClassCreate 函数的代码:
function _ClassCreate(AClass: TClass; Alloc: Boolean): TObject;
asm
{ -> EAX = pointer to VMT }
{ <- EAX = pointer to instance }
PUSH EDX ; 保存寄存器
PUSH ECX
PUSH EBX
TEST DL,DL ; 如果 dl = 0 则不调用 TObject.NewInstance
JL @@noAlloc
CALL DWORD PTR [EAX] + VMTOFFSET TObject.NewInstance ; 调用 TObject.NewInstance
@@noAlloc:
{$IFNDEF PC_MAPPED_EXCEPTIONS} ; 设置 PC 架构的结构化异常处理
XOR EDX,EDX
LEA ECX,[ESP+16]
MOV EBX,FS:[EDX]
MOV [ECX].TExcFrame.next,EBX
MOV [ECX].TExcFrame.hEBP,EBP
MOV [ECX].TExcFrame.desc,offset @desc
MOV [ECX].TexcFrame.ConstructedObject,EAX { trick: remember copy to instance }
MOV FS:[EDX],ECX
{$ENDIF}
POP EBX ; 恢复寄存器
POP ECX
POP EDX
RET
{$IFNDEF PC_MAPPED_EXCEPTIONS} ; 设置非 PC 架构的结构化异常处理
@desc:
JMP _HandleAnyException
{ destroy the object }
MOV EAX,[ESP+8+9*4]
MOV EAX,[EAX].TExcFrame.ConstructedObject
TEST EAX,EAX
JE @@skip
MOV ECX,[EAX]
MOV DL,$81
PUSH EAX
CALL DWORD PTR [ECX] + VMTOFFSET TObject.Destroy
POP EAX
CALL _ClassDestroy
@@skip:
{ reraise the exception }
CALL _RaiseAgain
{$ENDIF}
end;
==============================================================
⊙ 测试目标:查看 constructor 函数中 inherited 的编译器实现
==============================================================
⊙ 测试代码及反汇编代码:
type
TMyClass = class(TObject)
constructor Create;
end;
constructor TMyClass.Create;
begin
inherited; // 考查此句的实现
Beep;
end;
procedure Test; register;
var
Obj: TMyClass;
begin
Obj := TMyClass.Create;
mov dl, $01 ; class reference 时编译器设置 dl = 1
mov eax, [$004600ec] ; 设置 eax 为指向 TMyClass 的 VMT pointer
call TMyClass.Create ; 调用 TMyClass.Create
mov [ebp-$04], eax ; 保存 新建对象的指针
end;
constructor TMyClass.Create 的反汇编代码:
; 函数进入时 eax = pointer to VMT (dl = 1)
eax = pointer to instance (dl = 0)
; 函数返回时 eax = pointer to instance
begin
push ebp ; 这3句用于保存堆栈指针和创建堆栈
mov ebp, esp
add esp, -$08
test dl, dl ; 如果 dl = 0 则跳到 @ClassCreate 之后 @@1 处执行
jz +$08
add esp, -$10 ; 为 _ClassCreate 调用准备堆栈
call @ClassCreate ; 调用 System._ClassCreate,执行完成后 eax = 新建对象的指针
@@1:
mov [ebp-$05], dl ; 将 dl 值保存到堆栈中的 1 字节中,因为后面的 inherited TObject.Create
; 可能会改变 edx 的值
mov [ebp-$04], eax ; 保存 eax 到堆栈, eax = pointer to instance
inherited;
xor edx, edx ; 将 edx 清零(dl = 0),以通知 TObject.Create 不用再调用
; _ClassCreate 和 AfterConstructor (编译器实现)
mov eax, [ebp-$04] ; 将 eax 的值还原为前面保存在堆栈的 eax 值
; (这句是多余的,但在其它情况下可能必须执行此句)
call TObject.Create ; 调用 TObject.Create
Beep;
call Beep ; 继承类中 inherited 之后实现的功能
mov eax, [ebp-$04] ; 将 eax 的值还原为前面保存在堆栈的 eax 值
cmp byte ptr [ebp-$05], $00 ; (间接)检查 dl 是否 = 0
jz +$0f ; dl = 0 则跳过 _AfterConstruction 到 @@2 处
call @AfterConstruction ; 调用 System._AfterConstruction
pop dword ptr fs:[$00000000] ; 这2句恢复为 _ClassCreate 创建的堆栈空间
add esp, $0c
@@2:
mov eax, [ebp-$04] ; 返回 pointer to instance
end;
pop ecx
pop ecx
pop ebp
ret
结论:真是精妙!一个对象的正常的创建(Obj := TMyObj.Create, 与后面不正常的调用相对)过程是这样的:
1. 编译器保证第一个 constructor 调用之前 dl = 1
编译器保证 inherited Create 调用之前 dl = 0
2. dl = 1 时 编译器保证 Create 时 eax = pointer to class VMT
dl = 0 时 编译器保证 Create 时 eax = pointer to current object
3. 编译器保证任何层次的 constructor 调用后 eax = pointer to current object
4. dl = 1 时 编译器保证 Create 调用 System._ClassCreate,并与 constructor 相同的方式使用 eax
dl = 1 时 编译器保证 Create 调用 System._AfterConstruction,并且调用前后 eax = pointer to current object
dl = 0 时 编译器保证 Create 不会调用 System._ClassCreate
dl = 0 时 编译器保证 Create 不会调用 System._AfterConstruction
5. System._ClassCreate 中设置结构化异常处理,在 Create 即将结束时关闭结构化异常处理。
如果出错则会(1)释放由编译器分配的内存(2)恢复堆栈至创建对象之前(3)调用 TSomeClass.Destroy。
看上去有点繁杂,可是如果读懂了上面 TObject.Create 和 TMyObject.Create 则会感觉对象的创建非常清晰。
==================================================================================
⊙ 测试目标:以 object reference 和 class reference 调用构造函数的编译器实现
==================================================================================
⊙ static constructor 测试代码及反汇编代码 (省略了begin 和 end 后面的堆栈分配代码):
procedure Test; register;
var
Obj: TObject;
begin
Obj := TObject.Create;
mov dl, $01 ; 采用 class reference 时编译器自动设置 dl = 1
mov eax, [$004010a0] ; 把指向 TObject class VMT 的指针存入 eax,用于下一行调用
call TObject.Create
mov [ebp-$04], eax
Obj := Obj.Create;
or edx, -$01 ; 采用 object reference 时编译器自动设置 edx 的所有 bit 都为 1
mov eax, [ebp-$04] ; 把 Obj 指针的所指的区域(即对象内存空间)存入 eax,用于下一行调用
call TObject.Create
mov [ebp-$04], eax
end;
⊙ virtual constructor测试代码及反汇编代码 (省略了begin 和 end 后面的堆栈分配代码):
procedure Test; register;
var
Comp: TComponent;
begin
Comp := TComponent.Create(nil);
xor ecx, ecx ; 设置 参数 = nil
mov dl, $01 ; 设置 dl = 1
mov eax, [$00412eac] ; 设置 eax = class VMT pointer
call TComponent.Create ; 调用 TComponent.Create
mov [ebp-$04], eax ; 保存 新建的对象至 Comp
Comp := Comp.Create(nil);
xor ecx, ecx ; 同上
or edx, -$01 ; 设置 edx 所有位为 1
mov eax, [ebp-$04] ; 这句和下句 设置 ebx 为 TComponent cl