dlls/ntdll/exception.c

   1 /*
   2  * NT exception handling routines
   3  *
   4  * Copyright 1999 Turchanov Sergey
   5  * Copyright 1999 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <assert.h>
  23 #include <errno.h>
  24 #include <signal.h>
  25 #include <stdarg.h>
  26
  27 #define NONAMELESSUNION
  28 #define NONAMELESSSTRUCT
  29 #include "ntstatus.h"
  30 #define WIN32_NO_STATUS
  31 #include "windef.h"
  32 #include "winternl.h"
  33 #include "ddk/wdm.h"
  34 #include "wine/exception.h"
  35 #include "wine/server.h"
  36 #include "wine/list.h"
  37 #include "wine/debug.h"
  38 #include "excpt.h"
  39 #include "ntdll_misc.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(seh);
  42
  43 typedef struct
  44 {
  45     struct list                 entry;
  46     PVECTORED_EXCEPTION_HANDLER func;
  47     ULONG                       count;
  48 } VECTORED_HANDLER;
  49
  50 static struct list vectored_exception_handlers = LIST_INIT(vectored_exception_handlers);
  51 static struct list vectored_continue_handlers  = LIST_INIT(vectored_continue_handlers);
  52
  53 static RTL_CRITICAL_SECTION vectored_handlers_section;
  54 static RTL_CRITICAL_SECTION_DEBUG critsect_debug =
  55 {
  56     0, 0, &vectored_handlers_section,
  57     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  58       0, 0, { (DWORD_PTR)(__FILE__ ": vectored_handlers_section") }
  59 };
  60 static RTL_CRITICAL_SECTION vectored_handlers_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  61
  62 static PRTL_EXCEPTION_FILTER unhandled_exception_filter;
  63
  64
  65 static VECTORED_HANDLER *add_vectored_handler( struct list *handler_list, ULONG first,
  66                                                PVECTORED_EXCEPTION_HANDLER func )
  67 {
  68     VECTORED_HANDLER *handler = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*handler) );
  69     if (handler)
  70     {
  71         handler->func = RtlEncodePointer( func );
  72         handler->count = 1;
  73         RtlEnterCriticalSection( &vectored_handlers_section );
  74         if (first) list_add_head( handler_list, &handler->entry );
  75         else list_add_tail( handler_list, &handler->entry );
  76         RtlLeaveCriticalSection( &vectored_handlers_section );
  77     }
  78     return handler;
  79 }
  80
  81
  82 static ULONG remove_vectored_handler( struct list *handler_list, VECTORED_HANDLER *handler )
  83 {
  84     struct list *ptr;
  85     ULONG ret = FALSE;
  86
  87     RtlEnterCriticalSection( &vectored_handlers_section );
  88     LIST_FOR_EACH( ptr, handler_list )
  89     {
  90         VECTORED_HANDLER *curr_handler = LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
  91         if (curr_handler == handler)
  92         {
  93             if (!--curr_handler->count) list_remove( ptr );
  94             else handler = NULL;  /* don't free it yet */
  95             ret = TRUE;
  96             break;
  97         }
  98     }
  99     RtlLeaveCriticalSection( &vectored_handlers_section );
 100     if (ret) RtlFreeHeap( GetProcessHeap(), 0, handler );
 101     return ret;
 102 }
 103
 104
 105 /**********************************************************************
 106  *           call_vectored_handlers
 107  *
 108  * Call the vectored handlers chain.
 109  */
 110 LONG call_vectored_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
 111 {
 112     struct list *ptr;
 113     LONG ret = EXCEPTION_CONTINUE_SEARCH;
 114     EXCEPTION_POINTERS except_ptrs;
 115     PVECTORED_EXCEPTION_HANDLER func;
 116     VECTORED_HANDLER *handler, *to_free = NULL;
 117
 118     except_ptrs.ExceptionRecord = rec;
 119     except_ptrs.ContextRecord = context;
 120
 121     RtlEnterCriticalSection( &vectored_handlers_section );
 122     ptr = list_head( &vectored_exception_handlers );
 123     while (ptr)
 124     {
 125         handler = LIST_ENTRY( ptr, VECTORED_HANDLER, entry );
 126         handler->count++;
 127         func = RtlDecodePointer( handler->func );
 128         RtlLeaveCriticalSection( &vectored_handlers_section );
 129         RtlFreeHeap( GetProcessHeap(), 0, to_free );
 130         to_free = NULL;
 131
 132         TRACE( "calling handler at %p code=%x flags=%x\n",
 133                func, rec->ExceptionCode, rec->ExceptionFlags );
 134         ret = func( &except_ptrs );
 135         TRACE( "handler at %p returned %x\n", func, ret );
 136
 137         RtlEnterCriticalSection( &vectored_handlers_section );
 138         ptr = list_next( &vectored_exception_handlers, ptr );
 139         if (!--handler->count)  /* removed during execution */
 140         {
 141             list_remove( &handler->entry );
 142             to_free = handler;
 143         }
 144         if (ret == EXCEPTION_CONTINUE_EXECUTION) break;
 145     }
 146     RtlLeaveCriticalSection( &vectored_handlers_section );
 147     RtlFreeHeap( GetProcessHeap(), 0, to_free );
 148     return ret;
 149 }
 150
 151
 152 /*******************************************************************
 153  *              raise_status
 154  *
 155  * Implementation of RtlRaiseStatus with a specific exception record.
 156  */
 157 void raise_status( NTSTATUS status, EXCEPTION_RECORD *rec )
 158 {
 159     EXCEPTION_RECORD ExceptionRec;
 160
 161     ExceptionRec.ExceptionCode    = status;
 162     ExceptionRec.ExceptionFlags   = EH_NONCONTINUABLE;
 163     ExceptionRec.ExceptionRecord  = rec;
 164     ExceptionRec.NumberParameters = 0;
 165     for (;;) RtlRaiseException( &ExceptionRec );  /* never returns */
 166 }
 167
 168
 169 /***********************************************************************
 170  *            RtlRaiseStatus  (NTDLL.@)
 171  *
 172  * Raise an exception with ExceptionCode = status
 173  */
 174 void WINAPI RtlRaiseStatus( NTSTATUS status )
 175 {
 176     raise_status( status, NULL );
 177 }
 178
 179
 180 /*******************************************************************
 181  *              KiRaiseUserExceptionDispatcher  (NTDLL.@)
 182  */
 183 NTSTATUS WINAPI KiRaiseUserExceptionDispatcher(void)
 184 {
 185     DWORD code = NtCurrentTeb()->ExceptionCode;
 186     EXCEPTION_RECORD rec = { code };
 187     RtlRaiseException( &rec );
 188     return code;
 189 }
 190
 191
 192 /*******************************************************************
 193  *         RtlAddVectoredContinueHandler   (NTDLL.@)
 194  */
 195 PVOID WINAPI RtlAddVectoredContinueHandler( ULONG first, PVECTORED_EXCEPTION_HANDLER func )
 196 {
 197     return add_vectored_handler( &vectored_continue_handlers, first, func );
 198 }
 199
 200
 201 /*******************************************************************
 202  *         RtlRemoveVectoredContinueHandler   (NTDLL.@)
 203  */
 204 ULONG WINAPI RtlRemoveVectoredContinueHandler( PVOID handler )
 205 {
 206     return remove_vectored_handler( &vectored_continue_handlers, handler );
 207 }
 208
 209
 210 /*******************************************************************
 211  *         RtlAddVectoredExceptionHandler   (NTDLL.@)
 212  */
 213 PVOID WINAPI DECLSPEC_HOTPATCH RtlAddVectoredExceptionHandler( ULONG first, PVECTORED_EXCEPTION_HANDLER func )
 214 {
 215     return add_vectored_handler( &vectored_exception_handlers, first, func );
 216 }
 217
 218
 219 /*******************************************************************
 220  *         RtlRemoveVectoredExceptionHandler   (NTDLL.@)
 221  */
 222 ULONG WINAPI RtlRemoveVectoredExceptionHandler( PVOID handler )
 223 {
 224     return remove_vectored_handler( &vectored_exception_handlers, handler );
 225 }
 226
 227
 228 /*******************************************************************
 229  *         RtlSetUnhandledExceptionFilter   (NTDLL.@)
 230  */
 231 void WINAPI RtlSetUnhandledExceptionFilter( PRTL_EXCEPTION_FILTER filter )
 232 {
 233     unhandled_exception_filter = filter;
 234 }
 235
 236
 237 /*******************************************************************
 238  *         call_unhandled_exception_filter
 239  */
 240 LONG WINAPI call_unhandled_exception_filter( PEXCEPTION_POINTERS eptr )
 241 {
 242     if (!unhandled_exception_filter) return EXCEPTION_CONTINUE_SEARCH;
 243     return unhandled_exception_filter( eptr );
 244 }
 245
 246
 247 #if defined(__x86_64__) || defined(__arm__) || defined(__aarch64__)
 248
 249 struct dynamic_unwind_entry
 250 {
 251     struct list       entry;
 252     ULONG_PTR         base;
 253     ULONG_PTR         end;
 254     RUNTIME_FUNCTION *table;
 255     DWORD             count;
 256     DWORD             max_count;
 257     PGET_RUNTIME_FUNCTION_CALLBACK callback;
 258     PVOID             context;
 259 };
 260
 261 static struct list dynamic_unwind_list = LIST_INIT(dynamic_unwind_list);
 262
 263 static RTL_CRITICAL_SECTION dynamic_unwind_section;
 264 static RTL_CRITICAL_SECTION_DEBUG dynamic_unwind_debug =
 265 {
 266     0, 0, &dynamic_unwind_section,
 267     { &dynamic_unwind_debug.ProcessLocksList, &dynamic_unwind_debug.ProcessLocksList },
 268       0, 0, { (DWORD_PTR)(__FILE__ ": dynamic_unwind_section") }
 269 };
 270 static RTL_CRITICAL_SECTION dynamic_unwind_section = { &dynamic_unwind_debug, -1, 0, 0, 0, 0 };
 271
 272 static ULONG_PTR get_runtime_function_end( RUNTIME_FUNCTION *func, ULONG_PTR addr )
 273 {
 274 #ifdef __x86_64__
 275     return func->EndAddress;
 276 #elif defined(__arm__)
 277     if (func->u.s.Flag) return func->BeginAddress + func->u.s.FunctionLength * 2;
 278     else
 279     {
 280         struct unwind_info
 281         {
 282             DWORD function_length : 18;
 283             DWORD version : 2;
 284             DWORD x : 1;
 285             DWORD e : 1;
 286             DWORD f : 1;
 287             DWORD count : 5;
 288             DWORD words : 4;
 289         } *info = (struct unwind_info *)(addr + func->u.UnwindData);
 290         return func->BeginAddress + info->function_length * 2;
 291     }
 292 #else  /* __aarch64__ */
 293     if (func->u.s.Flag) return func->BeginAddress + func->u.s.FunctionLength * 4;
 294     else
 295     {
 296         struct unwind_info
 297         {
 298             DWORD function_length : 18;
 299             DWORD version : 2;
 300             DWORD x : 1;
 301             DWORD e : 1;
 302             DWORD epilog : 5;
 303             DWORD codes : 5;
 304         } *info = (struct unwind_info *)(addr + func->u.UnwindData);
 305         return func->BeginAddress + info->function_length * 4;
 306     }
 307 #endif
 308 }
 309
 310 /**********************************************************************
 311  *              RtlAddFunctionTable   (NTDLL.@)
 312  */
 313 BOOLEAN CDECL RtlAddFunctionTable( RUNTIME_FUNCTION *table, DWORD count, ULONG_PTR addr )
 314 {
 315     struct dynamic_unwind_entry *entry;
 316
 317     TRACE( "%p %u %lx\n", table, count, addr );
 318
 319     /* NOTE: Windows doesn't check if table is aligned or a NULL pointer */
 320
 321     entry = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*entry) );
 322     if (!entry)
 323         return FALSE;
 324
 325     entry->base      = addr;
 326     entry->end       = addr + (count ? get_runtime_function_end( &table[count - 1], addr ) : 0);
 327     entry->table     = table;
 328     entry->count     = count;
 329     entry->max_count = 0;
 330     entry->callback  = NULL;
 331     entry->context   = NULL;
 332
 333     RtlEnterCriticalSection( &dynamic_unwind_section );
 334     list_add_tail( &dynamic_unwind_list, &entry->entry );
 335     RtlLeaveCriticalSection( &dynamic_unwind_section );
 336     return TRUE;
 337 }
 338
 339
 340 /**********************************************************************
 341  *              RtlInstallFunctionTableCallback   (NTDLL.@)
 342  */
 343 BOOLEAN CDECL RtlInstallFunctionTableCallback( ULONG_PTR table, ULONG_PTR base, DWORD length,
 344                                                PGET_RUNTIME_FUNCTION_CALLBACK callback, PVOID context,
 345                                                PCWSTR dll )
 346 {
 347     struct dynamic_unwind_entry *entry;
 348
 349     TRACE( "%lx %lx %d %p %p %s\n", table, base, length, callback, context, wine_dbgstr_w(dll) );
 350
 351     /* NOTE: Windows doesn't check if the provided callback is a NULL pointer */
 352
 353     /* both low-order bits must be set */
 354     if ((table & 0x3) != 0x3)
 355         return FALSE;
 356
 357     entry = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*entry) );
 358     if (!entry)
 359         return FALSE;
 360
 361     entry->base      = base;
 362     entry->end       = base + length;
 363     entry->table     = (RUNTIME_FUNCTION *)table;
 364     entry->count     = 0;
 365     entry->max_count = 0;
 366     entry->callback  = callback;
 367     entry->context   = context;
 368
 369     RtlEnterCriticalSection( &dynamic_unwind_section );
 370     list_add_tail( &dynamic_unwind_list, &entry->entry );
 371     RtlLeaveCriticalSection( &dynamic_unwind_section );
 372
 373     return TRUE;
 374 }
 375
 376
 377 /*************************************************************************
 378  *              RtlAddGrowableFunctionTable   (NTDLL.@)
 379  */
 380 DWORD WINAPI RtlAddGrowableFunctionTable( void **table, RUNTIME_FUNCTION *functions, DWORD count,
 381                                           DWORD max_count, ULONG_PTR base, ULONG_PTR end )
 382 {
 383     struct dynamic_unwind_entry *entry;
 384
 385     TRACE( "%p, %p, %u, %u, %lx, %lx\n", table, functions, count, max_count, base, end );
 386
 387     entry = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*entry) );
 388     if (!entry)
 389         return STATUS_NO_MEMORY;
 390
 391     entry->base      = base;
 392     entry->end       = end;
 393     entry->table     = functions;
 394     entry->count     = count;
 395     entry->max_count = max_count;
 396     entry->callback  = NULL;
 397     entry->context   = NULL;
 398
 399     RtlEnterCriticalSection( &dynamic_unwind_section );
 400     list_add_tail( &dynamic_unwind_list, &entry->entry );
 401     RtlLeaveCriticalSection( &dynamic_unwind_section );
 402
 403     *table = entry;
 404
 405     return STATUS_SUCCESS;
 406 }
 407
 408
 409 /*************************************************************************
 410  *              RtlGrowFunctionTable   (NTDLL.@)
 411  */
 412 void WINAPI RtlGrowFunctionTable( void *table, DWORD count )
 413 {
 414     struct dynamic_unwind_entry *entry;
 415
 416     TRACE( "%p, %u\n", table, count );
 417
 418     RtlEnterCriticalSection( &dynamic_unwind_section );
 419     LIST_FOR_EACH_ENTRY( entry, &dynamic_unwind_list, struct dynamic_unwind_entry, entry )
 420     {
 421         if (entry == table)
 422         {
 423             if (count > entry->count && count <= entry->max_count)
 424                 entry->count = count;
 425             break;
 426         }
 427     }
 428     RtlLeaveCriticalSection( &dynamic_unwind_section );
 429 }
 430
 431
 432 /*************************************************************************
 433  *              RtlDeleteGrowableFunctionTable   (NTDLL.@)
 434  */
 435 void WINAPI RtlDeleteGrowableFunctionTable( void *table )
 436 {
 437     struct dynamic_unwind_entry *entry, *to_free = NULL;
 438
 439     TRACE( "%p\n", table );
 440
 441     RtlEnterCriticalSection( &dynamic_unwind_section );
 442     LIST_FOR_EACH_ENTRY( entry, &dynamic_unwind_list, struct dynamic_unwind_entry, entry )
 443     {
 444         if (entry == table)
 445         {
 446             to_free = entry;
 447             list_remove( &entry->entry );
 448             break;
 449         }
 450     }
 451     RtlLeaveCriticalSection( &dynamic_unwind_section );
 452
 453     RtlFreeHeap( GetProcessHeap(), 0, to_free );
 454 }
 455
 456
 457 /**********************************************************************
 458  *              RtlDeleteFunctionTable   (NTDLL.@)
 459  */
 460 BOOLEAN CDECL RtlDeleteFunctionTable( RUNTIME_FUNCTION *table )
 461 {
 462     struct dynamic_unwind_entry *entry, *to_free = NULL;
 463
 464     TRACE( "%p\n", table );
 465
 466     RtlEnterCriticalSection( &dynamic_unwind_section );
 467     LIST_FOR_EACH_ENTRY( entry, &dynamic_unwind_list, struct dynamic_unwind_entry, entry )
 468     {
 469         if (entry->table == table)
 470         {
 471             to_free = entry;
 472             list_remove( &entry->entry );
 473             break;
 474         }
 475     }
 476     RtlLeaveCriticalSection( &dynamic_unwind_section );
 477
 478     if (!to_free) return FALSE;
 479
 480     RtlFreeHeap( GetProcessHeap(), 0, to_free );
 481     return TRUE;
 482 }
 483
 484
 485 /* helper for lookup_function_info() */
 486 static RUNTIME_FUNCTION *find_function_info( ULONG_PTR pc, ULONG_PTR base,
 487                                              RUNTIME_FUNCTION *func, ULONG size )
 488 {
 489     int min = 0;
 490     int max = size - 1;
 491
 492     while (min <= max)
 493     {
 494 #ifdef __x86_64__
 495         int pos = (min + max) / 2;
 496         if (pc < base + func[pos].BeginAddress) max = pos - 1;
 497         else if (pc >= base + func[pos].EndAddress) min = pos + 1;
 498         else
 499         {
 500             func += pos;
 501             while (func->UnwindData & 1)  /* follow chained entry */
 502                 func = (RUNTIME_FUNCTION *)(base + (func->UnwindData & ~1));
 503             return func;
 504         }
 505 #elif defined(__arm__)
 506         int pos = (min + max) / 2;
 507         if (pc < base + (func[pos].BeginAddress & ~1)) max = pos - 1;
 508         else if (pc >= base + get_runtime_function_end( &func[pos], base )) min = pos + 1;
 509         else return func + pos;
 510 #else  /* __aarch64__ */
 511         int pos = (min + max) / 2;
 512         if (pc < base + func[pos].BeginAddress) max = pos - 1;
 513         else if (pc >= base + get_runtime_function_end( &func[pos], base )) min = pos + 1;
 514         else return func + pos;
 515 #endif
 516     }
 517     return NULL;
 518 }
 519
 520 /**********************************************************************
 521  *           lookup_function_info
 522  */
 523 RUNTIME_FUNCTION *lookup_function_info( ULONG_PTR pc, ULONG_PTR *base, LDR_DATA_TABLE_ENTRY **module )
 524 {
 525     RUNTIME_FUNCTION *func = NULL;
 526     struct dynamic_unwind_entry *entry;
 527     ULONG size;
 528
 529     /* PE module or wine module */
 530     if (!LdrFindEntryForAddress( (void *)pc, module ))
 531     {
 532         *base = (ULONG_PTR)(*module)->DllBase;
 533         if ((func = RtlImageDirectoryEntryToData( (*module)->DllBase, TRUE,
 534                                                   IMAGE_DIRECTORY_ENTRY_EXCEPTION, &size )))
 535         {
 536             /* lookup in function table */
 537             func = find_function_info( pc, (ULONG_PTR)(*module)->DllBase, func, size/sizeof(*func) );
 538         }
 539     }
 540     else
 541     {
 542         *module = NULL;
 543
 544         RtlEnterCriticalSection( &dynamic_unwind_section );
 545         LIST_FOR_EACH_ENTRY( entry, &dynamic_unwind_list, struct dynamic_unwind_entry, entry )
 546         {
 547             if (pc >= entry->base && pc < entry->end)
 548             {
 549                 *base = entry->base;
 550                 /* use callback or lookup in function table */
 551                 if (entry->callback)
 552                     func = entry->callback( pc, entry->context );
 553                 else
 554                     func = find_function_info( pc, entry->base, entry->table, entry->count );
 555                 break;
 556             }
 557         }
 558         RtlLeaveCriticalSection( &dynamic_unwind_section );
 559     }
 560
 561     return func;
 562 }
 563
 564 /**********************************************************************
 565  *              RtlLookupFunctionEntry   (NTDLL.@)
 566  */
 567 PRUNTIME_FUNCTION WINAPI RtlLookupFunctionEntry( ULONG_PTR pc, ULONG_PTR *base,
 568                                                  UNWIND_HISTORY_TABLE *table )
 569 {
 570     LDR_DATA_TABLE_ENTRY *module;
 571     RUNTIME_FUNCTION *func;
 572
 573     /* FIXME: should use the history table to make things faster */
 574
 575     if (!(func = lookup_function_info( pc, base, &module )))
 576     {
 577         *base = 0;
 578         WARN( "no exception table found for %lx\n", pc );
 579     }
 580     return func;
 581 }
 582
 583 #endif  /* __x86_64__ || __arm__ || __aarch64__ */
 584
 585
 586 /*************************************************************
 587  *            _assert
 588  */
 589 void __cdecl _assert( const char *str, const char *file, unsigned int line )
 590 {
 591     ERR( "%s:%u: Assertion failed %s\n", file, line, debugstr_a(str) );
 592     RtlRaiseStatus( EXCEPTION_WINE_ASSERTION );
 593 }
 594
 595
 596 /*************************************************************
 597  *            __wine_spec_unimplemented_stub
 598  *
 599  * ntdll-specific implementation to avoid depending on kernel functions.
 600  * Can be removed once ntdll.spec no longer contains stubs.
 601  */
 602 void __cdecl __wine_spec_unimplemented_stub( const char *module, const char *function )
 603 {
 604     EXCEPTION_RECORD record;
 605
 606     record.ExceptionCode    = EXCEPTION_WINE_STUB;
 607     record.ExceptionFlags   = EH_NONCONTINUABLE;
 608     record.ExceptionRecord  = NULL;
 609     record.ExceptionAddress = __wine_spec_unimplemented_stub;
 610     record.NumberParameters = 2;
 611     record.ExceptionInformation[0] = (ULONG_PTR)module;
 612     record.ExceptionInformation[1] = (ULONG_PTR)function;
 613     for (;;) RtlRaiseException( &record );
 614 }
 615
 616
 617 /*************************************************************
 618  *            IsBadStringPtrA
 619  *
 620  * IsBadStringPtrA replacement for ntdll, to catch exception in debug traces.
 621  */
 622 BOOL WINAPI IsBadStringPtrA( LPCSTR str, UINT_PTR max )
 623 {
 624     if (!str) return TRUE;
 625     __TRY
 626     {
 627         volatile const char *p = str;
 628         while (p != str + max) if (!*p++) break;
 629     }
 630     __EXCEPT_PAGE_FAULT
 631     {
 632         return TRUE;
 633     }
 634     __ENDTRY
 635     return FALSE;
 636 }
 637 __ASM_STDCALL_IMPORT(IsBadStringPtrA,8)
 638
 639 /*************************************************************
 640  *            IsBadStringPtrW
 641  *
 642  * IsBadStringPtrW replacement for ntdll, to catch exception in debug traces.
 643  */
 644 BOOL WINAPI IsBadStringPtrW( LPCWSTR str, UINT_PTR max )
 645 {
 646     if (!str) return TRUE;
 647     __TRY
 648     {
 649         volatile const WCHAR *p = str;
 650         while (p != str + max) if (!*p++) break;
 651     }
 652     __EXCEPT_PAGE_FAULT
 653     {
 654         return TRUE;
 655     }
 656     __ENDTRY
 657     return FALSE;
 658 }
 659 __ASM_STDCALL_IMPORT(IsBadStringPtrW,8)
 660
 661
 662 /**********************************************************************
 663  *              RtlGetEnabledExtendedFeatures   (NTDLL.@)
 664  */
 665 ULONG64 WINAPI RtlGetEnabledExtendedFeatures(ULONG64 feature_mask)
 666 {
 667     return user_shared_data->XState.EnabledFeatures & feature_mask;
 668 }
 669
 670 struct context_copy_range
 671 {
 672     ULONG start;
 673     ULONG flag;
 674 };
 675
 676 static const struct context_copy_range copy_ranges_amd64[] =
 677 {
 678     {0x38, 0x1}, {0x3a, 0x4}, { 0x42, 0x1}, { 0x48, 0x10}, { 0x78,  0x2}, { 0x98, 0x1},
 679     {0xa0, 0x2}, {0xf8, 0x1}, {0x100, 0x8}, {0x2a0,    0}, {0x4b0, 0x10}, {0x4d0,   0}
 680 };
 681
 682 static const struct context_copy_range copy_ranges_x86[] =
 683 {
 684     {  0x4, 0x10}, {0x1c, 0x8}, {0x8c, 0x4}, {0x9c, 0x2}, {0xb4, 0x1}, {0xcc, 0x20}, {0x1ec, 0},
 685     {0x2cc,    0},
 686 };
 687
 688 static const struct context_parameters
 689 {
 690     ULONG arch_flag;
 691     ULONG supported_flags;
 692     ULONG context_size;    /* sizeof(CONTEXT) */
 693     ULONG legacy_size;     /* Legacy context size */
 694     ULONG context_ex_size; /* sizeof(CONTEXT_EX) */
 695     ULONG alignment;       /* Used when computing size of context. */
 696     ULONG true_alignment;  /* Used for actual alignment. */
 697     ULONG flags_offset;
 698     const struct context_copy_range *copy_ranges;
 699 }
 700 arch_context_parameters[] =
 701 {
 702     {0x00100000, 0xd810005f, 0x4d0, 0x4d0, 0x20, 7, 0xf, 0x30, copy_ranges_amd64},
 703     {0x00010000, 0xd801007f, 0x2cc,  0xcc, 0x18, 3, 0x3,    0,   copy_ranges_x86},
 704 };
 705
 706 static const struct context_parameters *context_get_parameters( ULONG context_flags )
 707 {
 708     unsigned int i;
 709
 710     for (i = 0; i < ARRAY_SIZE(arch_context_parameters); ++i)
 711     {
 712         if (context_flags & arch_context_parameters[i].arch_flag)
 713             return context_flags & ~arch_context_parameters[i].supported_flags ? NULL : &arch_context_parameters[i];
 714     }
 715     return NULL;
 716 }
 717
 718
 719 /**********************************************************************
 720  *              RtlGetExtendedContextLength2    (NTDLL.@)
 721  */
 722 NTSTATUS WINAPI RtlGetExtendedContextLength2( ULONG context_flags, ULONG *length, ULONG64 compaction_mask )
 723 {
 724     const struct context_parameters *p;
 725     ULONG64 supported_mask;
 726     ULONG64 size;
 727
 728     TRACE( "context_flags %#x, length %p, compaction_mask %s.\n", context_flags, length,
 729             wine_dbgstr_longlong(compaction_mask) );
 730
 731     if (!(p = context_get_parameters( context_flags )))
 732         return STATUS_INVALID_PARAMETER;
 733
 734     if (!(context_flags & 0x40))
 735     {
 736         *length = p->context_size + p->context_ex_size + p->alignment;
 737         return STATUS_SUCCESS;
 738     }
 739
 740     if (!(supported_mask = RtlGetEnabledExtendedFeatures( ~(ULONG64)0) ))
 741         return STATUS_NOT_SUPPORTED;
 742
 743     compaction_mask &= supported_mask;
 744
 745     size = p->context_size + p->context_ex_size + offsetof(XSTATE, YmmContext) + 63;
 746
 747     if (compaction_mask & supported_mask & (1 << XSTATE_AVX))
 748         size += sizeof(YMMCONTEXT);
 749
 750     *length = size;
 751     return STATUS_SUCCESS;
 752 }
 753
 754
 755 /**********************************************************************
 756  *              RtlGetExtendedContextLength    (NTDLL.@)
 757  */
 758 NTSTATUS WINAPI RtlGetExtendedContextLength( ULONG context_flags, ULONG *length )
 759 {
 760     return RtlGetExtendedContextLength2( context_flags, length, ~(ULONG64)0 );
 761 }
 762
 763
 764 /**********************************************************************
 765  *              RtlInitializeExtendedContext2    (NTDLL.@)
 766  */
 767 NTSTATUS WINAPI RtlInitializeExtendedContext2( void *context, ULONG context_flags, CONTEXT_EX **context_ex,
 768         ULONG64 compaction_mask )
 769 {
 770     const struct context_parameters *p;
 771     ULONG64 supported_mask = 0;
 772     CONTEXT_EX *c_ex;
 773
 774     TRACE( "context %p, context_flags %#x, context_ex %p, compaction_mask %s.\n",
 775             context, context_flags, context_ex, wine_dbgstr_longlong(compaction_mask));
 776
 777     if (!(p = context_get_parameters( context_flags )))
 778         return STATUS_INVALID_PARAMETER;
 779
 780     if ((context_flags & 0x40) && !(supported_mask = RtlGetEnabledExtendedFeatures( ~(ULONG64)0 )))
 781         return STATUS_NOT_SUPPORTED;
 782
 783     context = (void *)(((ULONG_PTR)context + p->true_alignment) & ~p->true_alignment);
 784     *(ULONG *)((BYTE *)context + p->flags_offset) = context_flags;
 785
 786     *context_ex = c_ex = (CONTEXT_EX *)((BYTE *)context + p->context_size);
 787     c_ex->Legacy.Offset = c_ex->All.Offset = -(LONG)p->context_size;
 788     c_ex->Legacy.Length = context_flags & 0x20 ? p->context_size : p->legacy_size;
 789
 790     if (context_flags & 0x40)
 791     {
 792         XSTATE *xs;
 793
 794         compaction_mask &= supported_mask;
 795
 796         xs = (XSTATE *)(((ULONG_PTR)c_ex + p->context_ex_size + 63) & ~(ULONG_PTR)63);
 797
 798         c_ex->XState.Offset = (ULONG_PTR)xs - (ULONG_PTR)c_ex;
 799         c_ex->XState.Length = offsetof(XSTATE, YmmContext);
 800         compaction_mask &= supported_mask;
 801
 802         if (compaction_mask & (1 << XSTATE_AVX))
 803             c_ex->XState.Length += sizeof(YMMCONTEXT);
 804
 805         memset( xs, 0, c_ex->XState.Length );
 806         if (user_shared_data->XState.CompactionEnabled)
 807             xs->CompactionMask = ((ULONG64)1 << 63) | compaction_mask;
 808
 809         c_ex->All.Length = p->context_size + c_ex->XState.Offset + c_ex->XState.Length;
 810     }
 811     else
 812     {
 813         c_ex->XState.Offset = 25; /* According to the tests, it is just 25 if CONTEXT_XSTATE is not specified. */
 814         c_ex->XState.Length = 0;
 815         c_ex->All.Length = p->context_size + 24; /* sizeof(CONTEXT_EX) minus 8 alignment bytes on x64. */
 816     }
 817
 818     return STATUS_SUCCESS;
 819 }
 820
 821
 822 /**********************************************************************
 823  *              RtlInitializeExtendedContext    (NTDLL.@)
 824  */
 825 NTSTATUS WINAPI RtlInitializeExtendedContext( void *context, ULONG context_flags, CONTEXT_EX **context_ex )
 826 {
 827     return RtlInitializeExtendedContext2( context, context_flags, context_ex, ~(ULONG64)0 );
 828 }
 829
 830
 831 /**********************************************************************
 832  *              RtlLocateExtendedFeature2    (NTDLL.@)
 833  */
 834 void * WINAPI RtlLocateExtendedFeature2( CONTEXT_EX *context_ex, ULONG feature_id,
 835         XSTATE_CONFIGURATION *xstate_config, ULONG *length )
 836 {
 837     TRACE( "context_ex %p, feature_id %u, xstate_config %p, length %p.\n",
 838             context_ex, feature_id, xstate_config, length );
 839
 840     if (!xstate_config)
 841     {
 842         FIXME( "NULL xstate_config.\n" );
 843         return NULL;
 844     }
 845
 846     if (xstate_config != &user_shared_data->XState)
 847     {
 848         FIXME( "Custom xstate configuration is not supported.\n" );
 849         return NULL;
 850     }
 851
 852     if (feature_id != XSTATE_AVX)
 853         return NULL;
 854
 855     if (length)
 856         *length = sizeof(YMMCONTEXT);
 857
 858     if (context_ex->XState.Length < sizeof(XSTATE))
 859         return NULL;
 860
 861     return (BYTE *)context_ex + context_ex->XState.Offset + offsetof(XSTATE, YmmContext);
 862 }
 863
 864
 865 /**********************************************************************
 866  *              RtlLocateExtendedFeature    (NTDLL.@)
 867  */
 868 void * WINAPI RtlLocateExtendedFeature( CONTEXT_EX *context_ex, ULONG feature_id,
 869         ULONG *length )
 870 {
 871     return RtlLocateExtendedFeature2( context_ex, feature_id, &user_shared_data->XState, length );
 872 }
 873
 874 /**********************************************************************
 875  *              RtlLocateLegacyContext      (NTDLL.@)
 876  */
 877 void * WINAPI RtlLocateLegacyContext( CONTEXT_EX *context_ex, ULONG *length )
 878 {
 879     if (length)
 880         *length = context_ex->Legacy.Length;
 881
 882     return (BYTE *)context_ex + context_ex->Legacy.Offset;
 883 }
 884
 885 /**********************************************************************
 886  *              RtlSetExtendedFeaturesMask  (NTDLL.@)
 887  */
 888 void WINAPI RtlSetExtendedFeaturesMask( CONTEXT_EX *context_ex, ULONG64 feature_mask )
 889 {
 890     XSTATE *xs = (XSTATE *)((BYTE *)context_ex + context_ex->XState.Offset);
 891
 892     xs->Mask = RtlGetEnabledExtendedFeatures( feature_mask ) & ~(ULONG64)3;
 893 }
 894
 895
 896 /**********************************************************************
 897  *              RtlGetExtendedFeaturesMask  (NTDLL.@)
 898  */
 899 ULONG64 WINAPI RtlGetExtendedFeaturesMask( CONTEXT_EX *context_ex )
 900 {
 901     XSTATE *xs = (XSTATE *)((BYTE *)context_ex + context_ex->XState.Offset);
 902
 903     return xs->Mask & ~(ULONG64)3;
 904 }
 905
 906
 907 /**********************************************************************
 908  *              RtlCopyExtendedContext      (NTDLL.@)
 909  */
 910 NTSTATUS WINAPI RtlCopyExtendedContext( CONTEXT_EX *dst, ULONG context_flags, CONTEXT_EX *src )
 911 {
 912     const struct context_copy_range *range;
 913     const struct context_parameters *p;
 914     XSTATE *dst_xs, *src_xs;
 915     ULONG64 feature_mask;
 916     unsigned int start;
 917     BYTE *d, *s;
 918
 919     TRACE( "dst %p, context_flags %#x, src %p.\n", dst, context_flags, src );
 920
 921     if (!(p = context_get_parameters( context_flags )))
 922         return STATUS_INVALID_PARAMETER;
 923
 924     if (!(feature_mask = RtlGetEnabledExtendedFeatures( ~(ULONG64)0 )) && context_flags & 0x40)
 925         return STATUS_NOT_SUPPORTED;
 926
 927     d = RtlLocateLegacyContext( dst, NULL );
 928     s = RtlLocateLegacyContext( src, NULL );
 929
 930     *((ULONG *)(d + p->flags_offset)) |= context_flags;
 931
 932     start = 0;
 933     range = p->copy_ranges;
 934     do
 935     {
 936         if (range->flag & context_flags)
 937         {
 938             if (!start)
 939                 start = range->start;
 940         }
 941         else if (start)
 942         {
 943             memcpy( d + start, s + start, range->start - start );
 944             start = 0;
 945         }
 946     }
 947     while (range++->start != p->context_size);
 948
 949     if (!(context_flags & 0x40))
 950         return STATUS_SUCCESS;
 951
 952     if (dst->XState.Length < offsetof(XSTATE, YmmContext))
 953         return STATUS_BUFFER_OVERFLOW;
 954
 955     dst_xs = (XSTATE *)((BYTE *)dst + dst->XState.Offset);
 956     src_xs = (XSTATE *)((BYTE *)src + src->XState.Offset);
 957
 958     memset(dst_xs, 0, offsetof(XSTATE, YmmContext));
 959     dst_xs->Mask = (src_xs->Mask & ~(ULONG64)3) & feature_mask;
 960     dst_xs->CompactionMask = user_shared_data->XState.CompactionEnabled
 961             ? ((ULONG64)1 << 63) | (src_xs->CompactionMask & feature_mask) : 0;
 962
 963     if (dst_xs->Mask & 4 && src->XState.Length >= sizeof(XSTATE) && dst->XState.Length >= sizeof(XSTATE))
 964         memcpy( &dst_xs->YmmContext, &src_xs->YmmContext, sizeof(dst_xs->YmmContext) );
 965     return STATUS_SUCCESS;
 966 }