var s:string;
begin
 s:='Test';
end.

 Address         Publics by Value

0001:00000000       @GetMem
0001:00000010       @FreeMem
0001:00000020       Move
0001:00000080       @LStrAsg
0001:000000C4       @NewAnsiString
0001:000000F0       ExitProcess
0001:000000F8       GetProcessHeap
0001:00000100       HeapAlloc
0001:00000108       HeapFree
0001:00000110       System
0001:00000114       SysInit
0001:00000138       PROGRAM
0002:00001000       s

procedure       _HandleFinally;
asm
{$IFDEF PC_MAPPED_EXCEPTIONS}
{$IFDEF PIC}
       MOV     ESI, EBX
{$ENDIF}
       CMP     ECX, UW_EXC_CLASS_BORLANDCPP    // C++ exception?
       JNE     @@handleIt                      // nope, handle it
       // unwinding a C++ exception.  We handle that specially.
       PUSH    EAX
       PUSH    EDX
       PUSH    ECX
       MOV     EDX, [ESP+12]
       CALL    EDX
       POP     ECX
       POP     EDX
       POP     EAX
       CALL    SysRaiseCPPException

@@handleIt:
       PUSH    EAX
       PUSH    EDX
       CALL    UnblockOSExceptions
       POP     EDX
       POP     EAX

       // If the exception is a Delphi exception thrown from C++, coopt it.
       CALL    MaybeCooptException

       MOV     EDX, [ESP]
       CALL    NotifyExceptFinally
       PUSH    EAX
{$IFDEF PIC}
       MOV     EBX, ESI
{$ENDIF}
       {
         Mark the current exception with the EBP of the handler.  If
         an exception is raised from the finally block, then this
         exception will be orphaned.  We will catch this later, when
         we clean up the next except block to complete execution.
         See DoneExcept.
       }
       MOV [EAX].TRaisedException.HandlerEBP, EBP
       CALL    EDX
       POP     EAX
       {
         We executed the finally handler without adverse reactions.
         It's safe to clear the marker now.
       }
       MOV [EAX].TRaisedException.HandlerEBP, $FFFFFFFF
       PUSH    EBP
       MOV     EBP, ESP
       CALL    SysRaiseException             // Should be using resume here
{$ENDIF}
{$IFDEF MSWINDOWS}
       { ->    [ESP+ 4] excPtr: PExceptionRecord       }
       {       [ESP+ 8] errPtr: PExcFrame              }
       {       [ESP+12] ctxPtr: Pointer                }
       {       [ESP+16] dspPtr: Pointer                }
       { <-    EAX return value - always one   }

       MOV     EAX,[ESP+4]
       MOV     EDX,[ESP+8]
       TEST    [EAX].TExceptionRecord.ExceptionFlags,cUnwindInProgress
       JE      @@exit
       MOV     ECX,[EDX].TExcFrame.desc
       MOV     [EDX].TExcFrame.desc,offset @@exit

       PUSH    EBX
       PUSH    ESI
       PUSH    EDI
       PUSH    EBP

       MOV     EBP,[EDX].TExcFrame.hEBP
       ADD     ECX,TExcDesc.instructions
       CALL    NotifyExceptFinally
       CALL    ECX

       POP     EBP
       POP     EDI
       POP     ESI
       POP     EBX

@@exit:
       MOV     EAX,1
{$ENDIF}
end;

mov fs:[eax],esp