dlls/ntdll/signal_i386.c

   1 /*
   2  * i386 signal handling routines
   3  *
   4  * Copyright 1999 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #ifdef __i386__
  22
  23 #include <errno.h>
  24 #include <signal.h>
  25 #include <stdlib.h>
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <sys/types.h>
  29
  30 #include "ntstatus.h"
  31 #define WIN32_NO_STATUS
  32 #include "windef.h"
  33 #include "ntdll_misc.h"
  34 #include "wine/exception.h"
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(seh);
  38 WINE_DECLARE_DEBUG_CHANNEL(threadname);
  39
  40 struct x86_thread_data
  41 {
  42     DWORD              fs;            /* 1d4 TEB selector */
  43     DWORD              gs;            /* 1d8 libc selector; update winebuild if you move this! */
  44     DWORD              dr0;           /* 1dc debug registers */
  45     DWORD              dr1;           /* 1e0 */
  46     DWORD              dr2;           /* 1e4 */
  47     DWORD              dr3;           /* 1e8 */
  48     DWORD              dr6;           /* 1ec */
  49     DWORD              dr7;           /* 1f0 */
  50     void              *exit_frame;    /* 1f4 exit frame pointer */
  51 };
  52
  53 C_ASSERT( sizeof(struct x86_thread_data) <= 16 * sizeof(void *) );
  54 C_ASSERT( offsetof( TEB, GdiTebBatch ) + offsetof( struct x86_thread_data, gs ) == 0x1d8 );
  55 C_ASSERT( offsetof( TEB, GdiTebBatch ) + offsetof( struct x86_thread_data, exit_frame ) == 0x1f4 );
  56
  57 static inline struct x86_thread_data *x86_thread_data(void)
  58 {
  59     return (struct x86_thread_data *)&NtCurrentTeb()->GdiTebBatch;
  60 }
  61
  62 /* Exception record for handling exceptions happening inside exception handlers */
  63 typedef struct
  64 {
  65     EXCEPTION_REGISTRATION_RECORD frame;
  66     EXCEPTION_REGISTRATION_RECORD *prevFrame;
  67 } EXC_NESTED_FRAME;
  68
  69 extern DWORD EXC_CallHandler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
  70                               CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher,
  71                               PEXCEPTION_HANDLER handler, PEXCEPTION_HANDLER nested_handler );
  72
  73 /*******************************************************************
  74  *         is_valid_frame
  75  */
  76 static inline BOOL is_valid_frame( void *frame )
  77 {
  78     if ((ULONG_PTR)frame & 3) return FALSE;
  79     return (frame >= NtCurrentTeb()->Tib.StackLimit &&
  80             (void **)frame < (void **)NtCurrentTeb()->Tib.StackBase - 1);
  81 }
  82
  83 /*******************************************************************
  84  *         raise_handler
  85  *
  86  * Handler for exceptions happening inside a handler.
  87  */
  88 static DWORD raise_handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *frame,
  89                             CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher )
  90 {
  91     if (rec->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
  92         return ExceptionContinueSearch;
  93     /* We shouldn't get here so we store faulty frame in dispatcher */
  94     *dispatcher = ((EXC_NESTED_FRAME*)frame)->prevFrame;
  95     return ExceptionNestedException;
  96 }
  97
  98
  99 /*******************************************************************
 100  *         unwind_handler
 101  *
 102  * Handler for exceptions happening inside an unwind handler.
 103  */
 104 static DWORD unwind_handler( EXCEPTION_RECORD *rec, EXCEPTION_REGISTRATION_RECORD *frame,
 105                              CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **dispatcher )
 106 {
 107     if (!(rec->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)))
 108         return ExceptionContinueSearch;
 109     /* We shouldn't get here so we store faulty frame in dispatcher */
 110     *dispatcher = ((EXC_NESTED_FRAME*)frame)->prevFrame;
 111     return ExceptionCollidedUnwind;
 112 }
 113
 114
 115 /**********************************************************************
 116  *           call_stack_handlers
 117  *
 118  * Call the stack handlers chain.
 119  */
 120 static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
 121 {
 122     EXCEPTION_REGISTRATION_RECORD *frame, *dispatch, *nested_frame;
 123     DWORD res;
 124
 125     frame = NtCurrentTeb()->Tib.ExceptionList;
 126     nested_frame = NULL;
 127     while (frame != (EXCEPTION_REGISTRATION_RECORD*)~0UL)
 128     {
 129         /* Check frame address */
 130         if (!is_valid_frame( frame ))
 131         {
 132             rec->ExceptionFlags |= EH_STACK_INVALID;
 133             break;
 134         }
 135
 136         /* Call handler */
 137         TRACE( "calling handler at %p code=%lx flags=%lx\n",
 138                frame->Handler, rec->ExceptionCode, rec->ExceptionFlags );
 139         res = EXC_CallHandler( rec, frame, context, &dispatch, frame->Handler, raise_handler );
 140         TRACE( "handler at %p returned %lx\n", frame->Handler, res );
 141
 142         if (frame == nested_frame)
 143         {
 144             /* no longer nested */
 145             nested_frame = NULL;
 146             rec->ExceptionFlags &= ~EH_NESTED_CALL;
 147         }
 148
 149         switch(res)
 150         {
 151         case ExceptionContinueExecution:
 152             if (!(rec->ExceptionFlags & EH_NONCONTINUABLE)) return STATUS_SUCCESS;
 153             return STATUS_NONCONTINUABLE_EXCEPTION;
 154         case ExceptionContinueSearch:
 155             break;
 156         case ExceptionNestedException:
 157             if (nested_frame < dispatch) nested_frame = dispatch;
 158             rec->ExceptionFlags |= EH_NESTED_CALL;
 159             break;
 160         default:
 161             return STATUS_INVALID_DISPOSITION;
 162         }
 163         frame = frame->Prev;
 164     }
 165     return STATUS_UNHANDLED_EXCEPTION;
 166 }
 167
 168
 169 /*******************************************************************
 170  *              KiUserExceptionDispatcher (NTDLL.@)
 171  */
 172 NTSTATUS WINAPI dispatch_exception( EXCEPTION_RECORD *rec, CONTEXT *context )
 173 {
 174     NTSTATUS status;
 175     DWORD c;
 176
 177     TRACE( "code=%lx flags=%lx addr=%p ip=%08lx\n",
 178            rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress, context->Eip );
 179     for (c = 0; c < rec->NumberParameters; c++)
 180         TRACE( " info[%ld]=%08Ix\n", c, rec->ExceptionInformation[c] );
 181
 182     if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
 183     {
 184         if (rec->ExceptionInformation[1] >> 16)
 185             MESSAGE( "wine: Call from %p to unimplemented function %s.%s, aborting\n",
 186                      rec->ExceptionAddress,
 187                      (char*)rec->ExceptionInformation[0], (char*)rec->ExceptionInformation[1] );
 188         else
 189             MESSAGE( "wine: Call from %p to unimplemented function %s.%Id, aborting\n",
 190                      rec->ExceptionAddress,
 191                      (char*)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
 192     }
 193     else if (rec->ExceptionCode == EXCEPTION_WINE_NAME_THREAD && rec->ExceptionInformation[0] == 0x1000)
 194     {
 195         if ((DWORD)rec->ExceptionInformation[2] == -1)
 196             WARN_(threadname)( "Thread renamed to %s\n", debugstr_a((char *)rec->ExceptionInformation[1]) );
 197         else
 198             WARN_(threadname)( "Thread ID %04lx renamed to %s\n", (DWORD)rec->ExceptionInformation[2],
 199                                debugstr_a((char *)rec->ExceptionInformation[1]) );
 200
 201         set_native_thread_name((DWORD)rec->ExceptionInformation[2], (char *)rec->ExceptionInformation[1]);
 202     }
 203     else if (rec->ExceptionCode == DBG_PRINTEXCEPTION_C)
 204     {
 205         WARN( "%s\n", debugstr_an((char *)rec->ExceptionInformation[1], rec->ExceptionInformation[0] - 1) );
 206     }
 207     else if (rec->ExceptionCode == DBG_PRINTEXCEPTION_WIDE_C)
 208     {
 209         WARN( "%s\n", debugstr_wn((WCHAR *)rec->ExceptionInformation[1], rec->ExceptionInformation[0] - 1) );
 210     }
 211     else
 212     {
 213         if (rec->ExceptionCode == STATUS_ASSERTION_FAILURE)
 214             ERR( "%s exception (code=%lx) raised\n", debugstr_exception_code(rec->ExceptionCode), rec->ExceptionCode );
 215         else
 216             WARN( "%s exception (code=%lx) raised\n", debugstr_exception_code(rec->ExceptionCode), rec->ExceptionCode );
 217
 218         TRACE(" eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
 219               context->Eax, context->Ebx, context->Ecx,
 220               context->Edx, context->Esi, context->Edi );
 221         TRACE(" ebp=%08lx esp=%08lx cs=%04lx ss=%04lx ds=%04lx es=%04lx fs=%04lx gs=%04lx flags=%08lx\n",
 222               context->Ebp, context->Esp, context->SegCs, context->SegSs, context->SegDs,
 223               context->SegEs, context->SegFs, context->SegGs, context->EFlags );
 224     }
 225
 226     if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION)
 227         NtContinue( context, FALSE );
 228
 229     if ((status = call_stack_handlers( rec, context )) == STATUS_SUCCESS)
 230         NtContinue( context, FALSE );
 231
 232     if (status != STATUS_UNHANDLED_EXCEPTION) RtlRaiseStatus( status );
 233     return NtRaiseException( rec, context, FALSE );
 234 }
 235
 236 __ASM_STDCALL_FUNC( KiUserExceptionDispatcher, 8,
 237                     "pushl 4(%esp)\n\t"
 238                     "pushl 4(%esp)\n\t"
 239                     "call " __ASM_STDCALL("dispatch_exception", 8) "\n\t"
 240                     "int3" )
 241
 242
 243 /*******************************************************************
 244  *              KiUserApcDispatcher (NTDLL.@)
 245  */
 246 void WINAPI KiUserApcDispatcher( CONTEXT *context, ULONG_PTR ctx, ULONG_PTR arg1, ULONG_PTR arg2,
 247                                  PNTAPCFUNC func )
 248 {
 249     func( ctx, arg1, arg2 );
 250     NtContinue( context, TRUE );
 251 }
 252
 253
 254 /*******************************************************************
 255  *              KiUserCallbackDispatcher (NTDLL.@)
 256  */
 257 void WINAPI KiUserCallbackDispatcher( ULONG id, void *args, ULONG len )
 258 {
 259     NTSTATUS status;
 260
 261     __TRY
 262     {
 263         NTSTATUS (WINAPI *func)(void *, ULONG) = ((void **)NtCurrentTeb()->Peb->KernelCallbackTable)[id];
 264         status = NtCallbackReturn( NULL, 0, func( args, len ));
 265     }
 266     __EXCEPT_ALL
 267     {
 268         ERR_(seh)( "ignoring exception\n" );
 269         status = NtCallbackReturn( 0, 0, 0 );
 270     }
 271     __ENDTRY
 272
 273     RtlRaiseStatus( status );
 274 }
 275
 276
 277 /***********************************************************************
 278  *           save_fpu
 279  *
 280  * Save the thread FPU context.
 281  */
 282 static inline void save_fpu( CONTEXT *context )
 283 {
 284 #ifdef __GNUC__
 285     struct
 286     {
 287         DWORD ControlWord;
 288         DWORD StatusWord;
 289         DWORD TagWord;
 290         DWORD ErrorOffset;
 291         DWORD ErrorSelector;
 292         DWORD DataOffset;
 293         DWORD DataSelector;
 294     }
 295     float_status;
 296
 297     context->ContextFlags |= CONTEXT_FLOATING_POINT;
 298     __asm__ __volatile__( "fnsave %0; fwait" : "=m" (context->FloatSave) );
 299
 300     /* Reset unmasked exceptions status to avoid firing an exception. */
 301     memcpy(&float_status, &context->FloatSave, sizeof(float_status));
 302     float_status.StatusWord &= float_status.ControlWord | 0xffffff80;
 303
 304     __asm__ __volatile__( "fldenv %0" : : "m" (float_status) );
 305 #endif
 306 }
 307
 308
 309 /***********************************************************************
 310  *           save_fpux
 311  *
 312  * Save the thread FPU extended context.
 313  */
 314 static inline void save_fpux( CONTEXT *context )
 315 {
 316 #ifdef __GNUC__
 317     /* we have to enforce alignment by hand */
 318     char buffer[sizeof(XSAVE_FORMAT) + 16];
 319     XSAVE_FORMAT *state = (XSAVE_FORMAT *)(((ULONG_PTR)buffer + 15) & ~15);
 320
 321     context->ContextFlags |= CONTEXT_EXTENDED_REGISTERS;
 322     __asm__ __volatile__( "fxsave %0" : "=m" (*state) );
 323     memcpy( context->ExtendedRegisters, state, sizeof(*state) );
 324 #endif
 325 }
 326
 327
 328 /***********************************************************************
 329  *              RtlCaptureContext (NTDLL.@)
 330  */
 331 __ASM_STDCALL_FUNC( RtlCaptureContext, 4,
 332                     "pushl %eax\n\t"
 333                     __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 334                     "movl 8(%esp),%eax\n\t"    /* context */
 335                     "movl $0x10007,(%eax)\n\t" /* context->ContextFlags */
 336                     "movw %gs,0x8c(%eax)\n\t"  /* context->SegGs */
 337                     "movw %fs,0x90(%eax)\n\t"  /* context->SegFs */
 338                     "movw %es,0x94(%eax)\n\t"  /* context->SegEs */
 339                     "movw %ds,0x98(%eax)\n\t"  /* context->SegDs */
 340                     "movl %edi,0x9c(%eax)\n\t" /* context->Edi */
 341                     "movl %esi,0xa0(%eax)\n\t" /* context->Esi */
 342                     "movl %ebx,0xa4(%eax)\n\t" /* context->Ebx */
 343                     "movl %edx,0xa8(%eax)\n\t" /* context->Edx */
 344                     "movl %ecx,0xac(%eax)\n\t" /* context->Ecx */
 345                     "movl 0(%ebp),%edx\n\t"
 346                     "movl %edx,0xb4(%eax)\n\t" /* context->Ebp */
 347                     "movl 4(%ebp),%edx\n\t"
 348                     "movl %edx,0xb8(%eax)\n\t" /* context->Eip */
 349                     "movw %cs,0xbc(%eax)\n\t"  /* context->SegCs */
 350                     "pushfl\n\t"
 351                     __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 352                     "popl 0xc0(%eax)\n\t"      /* context->EFlags */
 353                     __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
 354                     "leal 8(%ebp),%edx\n\t"
 355                     "movl %edx,0xc4(%eax)\n\t" /* context->Esp */
 356                     "movw %ss,0xc8(%eax)\n\t"  /* context->SegSs */
 357                     "popl 0xb0(%eax)\n\t"      /* context->Eax */
 358                     __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
 359                     "ret $4" )
 360
 361 /*******************************************************************
 362  *              RtlRestoreContext (NTDLL.@)
 363  */
 364 void CDECL RtlRestoreContext( CONTEXT *context, EXCEPTION_RECORD *rec )
 365 {
 366     TRACE( "returning to %p stack %p\n", (void *)context->Eip, (void *)context->Esp );
 367     NtContinue( context, FALSE );
 368 }
 369
 370 /*******************************************************************
 371  *              RtlUnwind (NTDLL.@)
 372  */
 373 void WINAPI DECLSPEC_HIDDEN __regs_RtlUnwind( EXCEPTION_REGISTRATION_RECORD* pEndFrame, PVOID targetIp,
 374                                               PEXCEPTION_RECORD pRecord, PVOID retval, CONTEXT *context )
 375 {
 376     EXCEPTION_RECORD record;
 377     EXCEPTION_REGISTRATION_RECORD *frame, *dispatch;
 378     DWORD res;
 379
 380     context->Eax = (DWORD)retval;
 381
 382     /* build an exception record, if we do not have one */
 383     if (!pRecord)
 384     {
 385         record.ExceptionCode    = STATUS_UNWIND;
 386         record.ExceptionFlags   = 0;
 387         record.ExceptionRecord  = NULL;
 388         record.ExceptionAddress = (void *)context->Eip;
 389         record.NumberParameters = 0;
 390         pRecord = &record;
 391     }
 392
 393     pRecord->ExceptionFlags |= EH_UNWINDING | (pEndFrame ? 0 : EH_EXIT_UNWIND);
 394
 395     TRACE( "code=%lx flags=%lx\n", pRecord->ExceptionCode, pRecord->ExceptionFlags );
 396     TRACE( "eax=%08lx ebx=%08lx ecx=%08lx edx=%08lx esi=%08lx edi=%08lx\n",
 397            context->Eax, context->Ebx, context->Ecx, context->Edx, context->Esi, context->Edi );
 398     TRACE( "ebp=%08lx esp=%08lx eip=%08lx cs=%04x ds=%04x fs=%04x gs=%04x flags=%08lx\n",
 399            context->Ebp, context->Esp, context->Eip, LOWORD(context->SegCs), LOWORD(context->SegDs),
 400            LOWORD(context->SegFs), LOWORD(context->SegGs), context->EFlags );
 401
 402     /* get chain of exception frames */
 403     frame = NtCurrentTeb()->Tib.ExceptionList;
 404     while ((frame != (EXCEPTION_REGISTRATION_RECORD*)~0UL) && (frame != pEndFrame))
 405     {
 406         /* Check frame address */
 407         if (pEndFrame && (frame > pEndFrame))
 408             raise_status( STATUS_INVALID_UNWIND_TARGET, pRecord );
 409
 410         if (!is_valid_frame( frame )) raise_status( STATUS_BAD_STACK, pRecord );
 411
 412         /* Call handler */
 413         TRACE( "calling handler at %p code=%lx flags=%lx\n",
 414                frame->Handler, pRecord->ExceptionCode, pRecord->ExceptionFlags );
 415         res = EXC_CallHandler( pRecord, frame, context, &dispatch, frame->Handler, unwind_handler );
 416         TRACE( "handler at %p returned %lx\n", frame->Handler, res );
 417
 418         switch(res)
 419         {
 420         case ExceptionContinueSearch:
 421             break;
 422         case ExceptionCollidedUnwind:
 423             frame = dispatch;
 424             break;
 425         default:
 426             raise_status( STATUS_INVALID_DISPOSITION, pRecord );
 427             break;
 428         }
 429         frame = __wine_pop_frame( frame );
 430     }
 431     NtContinue( context, FALSE );
 432 }
 433 __ASM_STDCALL_FUNC( RtlUnwind, 16,
 434                     "pushl %ebp\n\t"
 435                     __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 436                     __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 437                     "movl %esp,%ebp\n\t"
 438                     __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 439                     "leal -(0x2cc+8)(%esp),%esp\n\t" /* sizeof(CONTEXT) + alignment */
 440                     "pushl %eax\n\t"
 441                     "leal 4(%esp),%eax\n\t"          /* context */
 442                     "xchgl %eax,(%esp)\n\t"
 443                     "call " __ASM_STDCALL("RtlCaptureContext",4) "\n\t"
 444                     "leal 24(%ebp),%eax\n\t"
 445                     "movl %eax,0xc4(%esp)\n\t"       /* context->Esp */
 446                     "pushl %esp\n\t"
 447                     "pushl 20(%ebp)\n\t"
 448                     "pushl 16(%ebp)\n\t"
 449                     "pushl 12(%ebp)\n\t"
 450                     "pushl 8(%ebp)\n\t"
 451                     "call " __ASM_STDCALL("__regs_RtlUnwind",20) "\n\t"
 452                     "leave\n\t"
 453                     __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 454                     __ASM_CFI(".cfi_same_value %ebp\n\t")
 455                     "ret $16" )  /* actually never returns */
 456
 457
 458 /*******************************************************************
 459  *              raise_exception_full_context
 460  *
 461  * Raise an exception with the full CPU context.
 462  */
 463 void raise_exception_full_context( EXCEPTION_RECORD *rec, CONTEXT *context )
 464 {
 465     save_fpu( context );
 466     save_fpux( context );
 467     /* FIXME: xstate */
 468     context->Dr0 = x86_thread_data()->dr0;
 469     context->Dr1 = x86_thread_data()->dr1;
 470     context->Dr2 = x86_thread_data()->dr2;
 471     context->Dr3 = x86_thread_data()->dr3;
 472     context->Dr6 = x86_thread_data()->dr6;
 473     context->Dr7 = x86_thread_data()->dr7;
 474     context->ContextFlags |= CONTEXT_DEBUG_REGISTERS;
 475
 476     RtlRaiseStatus( NtRaiseException( rec, context, TRUE ));
 477 }
 478
 479
 480 /***********************************************************************
 481  *              RtlRaiseException (NTDLL.@)
 482  */
 483 __ASM_STDCALL_FUNC( RtlRaiseException, 4,
 484                     "pushl %ebp\n\t"
 485                     __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 486                     __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 487                     "movl %esp,%ebp\n\t"
 488                     __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 489                     "leal -0x2cc(%esp),%esp\n\t"  /* sizeof(CONTEXT) */
 490                     "pushl %esp\n\t"              /* context */
 491                     "call " __ASM_STDCALL("RtlCaptureContext",4) "\n\t"
 492                     "movl 4(%ebp),%eax\n\t"       /* return address */
 493                     "movl 8(%ebp),%ecx\n\t"       /* rec */
 494                     "movl %eax,12(%ecx)\n\t"      /* rec->ExceptionAddress */
 495                     "leal 12(%ebp),%eax\n\t"
 496                     "movl %eax,0xc4(%esp)\n\t"    /* context->Esp */
 497                     "movl %esp,%eax\n\t"
 498                     "pushl %eax\n\t"
 499                     "pushl %ecx\n\t"
 500                     "call " __ASM_NAME("raise_exception_full_context") "\n\t"
 501                     "leave\n\t"
 502                     __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 503                     __ASM_CFI(".cfi_same_value %ebp\n\t")
 504                     "ret $4" )  /* actually never returns */
 505
 506
 507 /*************************************************************************
 508  *              RtlCaptureStackBackTrace (NTDLL.@)
 509  */
 510 USHORT WINAPI RtlCaptureStackBackTrace( ULONG skip, ULONG count, PVOID *buffer, ULONG *hash )
 511 {
 512     CONTEXT context;
 513     ULONG i;
 514     ULONG *frame;
 515
 516     RtlCaptureContext( &context );
 517     if (hash) *hash = 0;
 518     frame = (ULONG *)context.Ebp;
 519
 520     while (skip--)
 521     {
 522         if (!is_valid_frame( frame )) return 0;
 523         frame = (ULONG *)*frame;
 524     }
 525
 526     for (i = 0; i < count; i++)
 527     {
 528         if (!is_valid_frame( frame )) break;
 529         buffer[i] = (void *)frame[1];
 530         if (hash) *hash += frame[1];
 531         frame = (ULONG *)*frame;
 532     }
 533     return i;
 534 }
 535
 536
 537 /***********************************************************************
 538  *           signal_start_thread
 539  */
 540 __ASM_GLOBAL_FUNC( signal_start_thread,
 541                    "movl 4(%esp),%esi\n\t"   /* context */
 542                    "leal -12(%esi),%edi\n\t"
 543                    /* clear the thread stack */
 544                    "andl $~0xfff,%edi\n\t"   /* round down to page size */
 545                    "movl $0xf0000,%ecx\n\t"
 546                    "subl %ecx,%edi\n\t"
 547                    "movl %edi,%esp\n\t"
 548                    "xorl %eax,%eax\n\t"
 549                    "shrl $2,%ecx\n\t"
 550                    "rep; stosl\n\t"
 551                    /* switch to the initial context */
 552                    "leal -12(%esi),%esp\n\t"
 553                    "movl $1,4(%esp)\n\t"
 554                    "movl %esi,(%esp)\n\t"
 555                    "call " __ASM_STDCALL("NtContinue", 8) )
 556
 557 /**********************************************************************
 558  *              DbgBreakPoint   (NTDLL.@)
 559  */
 560 __ASM_STDCALL_FUNC( DbgBreakPoint, 0, "int $3; ret"
 561                     "\n\tnop; nop; nop; nop; nop; nop; nop; nop"
 562                     "\n\tnop; nop; nop; nop; nop; nop" );
 563
 564 /**********************************************************************
 565  *              DbgUserBreakPoint   (NTDLL.@)
 566  */
 567 __ASM_STDCALL_FUNC( DbgUserBreakPoint, 0, "int $3; ret"
 568                     "\n\tnop; nop; nop; nop; nop; nop; nop; nop"
 569                     "\n\tnop; nop; nop; nop; nop; nop" );
 570
 571 /**********************************************************************
 572  *           NtCurrentTeb   (NTDLL.@)
 573  */
 574 __ASM_STDCALL_FUNC( NtCurrentTeb, 0, ".byte 0x64\n\tmovl 0x18,%eax\n\tret" )
 575
 576
 577 /**************************************************************************
 578  *           _chkstk   (NTDLL.@)
 579  */
 580 __ASM_GLOBAL_FUNC( _chkstk,
 581                    "negl %eax\n\t"
 582                    "addl %esp,%eax\n\t"
 583                    "xchgl %esp,%eax\n\t"
 584                    "movl 0(%eax),%eax\n\t"  /* copy return address from old location */
 585                    "movl %eax,0(%esp)\n\t"
 586                    "ret" )
 587
 588 /**************************************************************************
 589  *           _alloca_probe   (NTDLL.@)
 590  */
 591 __ASM_GLOBAL_FUNC( _alloca_probe,
 592                    "negl %eax\n\t"
 593                    "addl %esp,%eax\n\t"
 594                    "xchgl %esp,%eax\n\t"
 595                    "movl 0(%eax),%eax\n\t"  /* copy return address from old location */
 596                    "movl %eax,0(%esp)\n\t"
 597                    "ret" )
 598
 599
 600 /**********************************************************************
 601  *              EXC_CallHandler   (internal)
 602  *
 603  * Some exception handlers depend on EBP to have a fixed position relative to
 604  * the exception frame.
 605  * Shrinker depends on (*1) doing what it does,
 606  * (*2) being the exact instruction it is and (*3) beginning with 0x64
 607  * (i.e. the %fs prefix to the movl instruction). It also depends on the
 608  * function calling the handler having only 5 parameters (*4).
 609  */
 610 __ASM_GLOBAL_FUNC( EXC_CallHandler,
 611                   "pushl %ebp\n\t"
 612                   __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 613                   __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 614                   "movl %esp,%ebp\n\t"
 615                   __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 616                    "pushl %ebx\n\t"
 617                    __ASM_CFI(".cfi_rel_offset %ebx,-4\n\t")
 618                    "movl 28(%ebp), %edx\n\t" /* ugly hack to pass the 6th param needed because of Shrinker */
 619                    "pushl 24(%ebp)\n\t"
 620                    "pushl 20(%ebp)\n\t"
 621                    "pushl 16(%ebp)\n\t"
 622                    "pushl 12(%ebp)\n\t"
 623                    "pushl 8(%ebp)\n\t"
 624                    "call " __ASM_NAME("call_exception_handler") "\n\t"
 625                    "popl %ebx\n\t"
 626                    __ASM_CFI(".cfi_same_value %ebx\n\t")
 627                    "leave\n"
 628                    __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 629                    __ASM_CFI(".cfi_same_value %ebp\n\t")
 630                    "ret" )
 631 __ASM_GLOBAL_FUNC(call_exception_handler,
 632                   "pushl %ebp\n\t"
 633                   __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
 634                   __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
 635                   "movl %esp,%ebp\n\t"
 636                   __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
 637                   "subl $12,%esp\n\t"
 638                   "pushl 12(%ebp)\n\t"      /* make any exceptions in this... */
 639                   "pushl %edx\n\t"          /* handler be handled by... */
 640                   ".byte 0x64\n\t"
 641                   "pushl (0)\n\t"           /* nested_handler (passed in edx). */
 642                   ".byte 0x64\n\t"
 643                   "movl %esp,(0)\n\t"       /* push the new exception frame onto the exception stack. */
 644                   "pushl 20(%ebp)\n\t"
 645                   "pushl 16(%ebp)\n\t"
 646                   "pushl 12(%ebp)\n\t"
 647                   "pushl 8(%ebp)\n\t"
 648                   "movl 24(%ebp), %ecx\n\t" /* (*1) */
 649                   "call *%ecx\n\t"          /* call handler. (*2) */
 650                   ".byte 0x64\n\t"
 651                   "movl (0), %esp\n\t"      /* restore previous... (*3) */
 652                   ".byte 0x64\n\t"
 653                   "popl (0)\n\t"            /* exception frame. */
 654                   "movl %ebp, %esp\n\t"     /* restore saved stack, in case it was corrupted */
 655                   "popl %ebp\n\t"
 656                    __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
 657                    __ASM_CFI(".cfi_same_value %ebp\n\t")
 658                   "ret $20" )            /* (*4) */
 659
 660 #endif  /* __i386__ */