dlls/ntdll/signal_arm64ec.c

   1 /*
   2  * ARM64EC signal handling routines
   3  *
   4  * Copyright 1999, 2005, 2023 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 __arm64ec__
  22
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #include "windef.h"
  29 #include "winternl.h"
  30 #include "wine/exception.h"
  31 #include "wine/list.h"
  32 #include "ntdll_misc.h"
  33 #include "unwind.h"
  34 #include "wine/debug.h"
  35 #include "ntsyscalls.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(seh);
  38 WINE_DECLARE_DEBUG_CHANNEL(relay);
  39
  40 /*******************************************************************
  41  *         syscalls
  42  */
  43 enum syscall_ids
  44 {
  45 #define SYSCALL_ENTRY(id,name,args) __id_##name = id,
  46 ALL_SYSCALLS64
  47 #undef SYSCALL_ENTRY
  48 };
  49
  50 #define SYSCALL_API __attribute__((naked))
  51 #define SYSCALL_FUNC(name) __ASM_SYSCALL_FUNC( __id_##name, name )
  52
  53 NTSTATUS SYSCALL_API NtAcceptConnectPort( HANDLE *handle, ULONG id, LPC_MESSAGE *msg, BOOLEAN accept,
  54                                           LPC_SECTION_WRITE *write, LPC_SECTION_READ *read )
  55 {
  56     SYSCALL_FUNC( NtAcceptConnectPort );
  57 }
  58
  59 NTSTATUS SYSCALL_API NtAccessCheck( PSECURITY_DESCRIPTOR descr, HANDLE token, ACCESS_MASK access,
  60                                     GENERIC_MAPPING *mapping, PRIVILEGE_SET *privs, ULONG *retlen,
  61                                     ULONG *access_granted, NTSTATUS *access_status )
  62 {
  63     SYSCALL_FUNC( NtAccessCheck );
  64 }
  65
  66 NTSTATUS SYSCALL_API NtAccessCheckAndAuditAlarm( UNICODE_STRING *subsystem, HANDLE handle,
  67                                                  UNICODE_STRING *typename, UNICODE_STRING *objectname,
  68                                                  PSECURITY_DESCRIPTOR descr, ACCESS_MASK access,
  69                                                  GENERIC_MAPPING *mapping, BOOLEAN creation,
  70                                                  ACCESS_MASK *access_granted, BOOLEAN *access_status,
  71                                                  BOOLEAN *onclose )
  72 {
  73     SYSCALL_FUNC( NtAccessCheckAndAuditAlarm );
  74 }
  75
  76 NTSTATUS SYSCALL_API NtAddAtom( const WCHAR *name, ULONG length, RTL_ATOM *atom )
  77 {
  78     SYSCALL_FUNC( NtAddAtom );
  79 }
  80
  81 NTSTATUS SYSCALL_API NtAdjustGroupsToken( HANDLE token, BOOLEAN reset, TOKEN_GROUPS *groups,
  82                                           ULONG length, TOKEN_GROUPS *prev, ULONG *retlen )
  83 {
  84     SYSCALL_FUNC( NtAdjustGroupsToken );
  85 }
  86
  87 NTSTATUS SYSCALL_API NtAdjustPrivilegesToken( HANDLE token, BOOLEAN disable, TOKEN_PRIVILEGES *privs,
  88                                               DWORD length, TOKEN_PRIVILEGES *prev, DWORD *retlen )
  89 {
  90     SYSCALL_FUNC( NtAdjustPrivilegesToken );
  91 }
  92
  93 NTSTATUS SYSCALL_API NtAlertResumeThread( HANDLE handle, ULONG *count )
  94 {
  95     SYSCALL_FUNC( NtAlertResumeThread );
  96 }
  97
  98 NTSTATUS SYSCALL_API NtAlertThread( HANDLE handle )
  99 {
 100     SYSCALL_FUNC( NtAlertThread );
 101 }
 102
 103 NTSTATUS SYSCALL_API NtAlertThreadByThreadId( HANDLE tid )
 104 {
 105     SYSCALL_FUNC( NtAlertThreadByThreadId );
 106 }
 107
 108 NTSTATUS SYSCALL_API NtAllocateLocallyUniqueId( LUID *luid )
 109 {
 110     SYSCALL_FUNC( NtAllocateLocallyUniqueId );
 111 }
 112
 113 NTSTATUS SYSCALL_API NtAllocateUuids( ULARGE_INTEGER *time, ULONG *delta, ULONG *sequence, UCHAR *seed )
 114 {
 115     SYSCALL_FUNC( NtAllocateUuids );
 116 }
 117
 118 NTSTATUS SYSCALL_API NtAllocateVirtualMemory( HANDLE process, PVOID *ret, ULONG_PTR zero_bits,
 119                                               SIZE_T *size_ptr, ULONG type, ULONG protect )
 120 {
 121     SYSCALL_FUNC( NtAllocateVirtualMemory );
 122 }
 123
 124 NTSTATUS SYSCALL_API NtAllocateVirtualMemoryEx( HANDLE process, PVOID *ret, SIZE_T *size_ptr, ULONG type,
 125                                                 ULONG protect, MEM_EXTENDED_PARAMETER *parameters,
 126                                                 ULONG count )
 127 {
 128     SYSCALL_FUNC( NtAllocateVirtualMemoryEx );
 129 }
 130
 131 NTSTATUS SYSCALL_API NtAreMappedFilesTheSame(PVOID addr1, PVOID addr2)
 132 {
 133     SYSCALL_FUNC( NtAreMappedFilesTheSame );
 134 }
 135
 136 NTSTATUS SYSCALL_API NtAssignProcessToJobObject( HANDLE job, HANDLE process )
 137 {
 138     SYSCALL_FUNC( NtAssignProcessToJobObject );
 139 }
 140
 141 NTSTATUS SYSCALL_API NtCallbackReturn( void *ret_ptr, ULONG ret_len, NTSTATUS status )
 142 {
 143     SYSCALL_FUNC( NtCallbackReturn );
 144 }
 145
 146 NTSTATUS SYSCALL_API NtCancelIoFile( HANDLE handle, IO_STATUS_BLOCK *io_status )
 147 {
 148     SYSCALL_FUNC( NtCancelIoFile );
 149 }
 150
 151 NTSTATUS SYSCALL_API NtCancelIoFileEx( HANDLE handle, IO_STATUS_BLOCK *io, IO_STATUS_BLOCK *io_status )
 152 {
 153     SYSCALL_FUNC( NtCancelIoFileEx );
 154 }
 155
 156 NTSTATUS SYSCALL_API NtCancelSynchronousIoFile( HANDLE handle, IO_STATUS_BLOCK *io,
 157                                                 IO_STATUS_BLOCK *io_status )
 158 {
 159     SYSCALL_FUNC( NtCancelSynchronousIoFile );
 160 }
 161
 162 NTSTATUS SYSCALL_API NtCancelTimer( HANDLE handle, BOOLEAN *state )
 163 {
 164     SYSCALL_FUNC( NtCancelTimer );
 165 }
 166
 167 NTSTATUS SYSCALL_API NtClearEvent( HANDLE handle )
 168 {
 169     SYSCALL_FUNC( NtClearEvent );
 170 }
 171
 172 NTSTATUS SYSCALL_API NtClose( HANDLE handle )
 173 {
 174     SYSCALL_FUNC( NtClose );
 175 }
 176
 177 NTSTATUS SYSCALL_API NtCommitTransaction( HANDLE transaction, BOOLEAN wait )
 178 {
 179     SYSCALL_FUNC( NtCommitTransaction );
 180 }
 181
 182 NTSTATUS SYSCALL_API NtCompareObjects( HANDLE first, HANDLE second )
 183 {
 184     SYSCALL_FUNC( NtCompareObjects );
 185 }
 186
 187 NTSTATUS SYSCALL_API NtCompareTokens( HANDLE first, HANDLE second, BOOLEAN *equal )
 188 {
 189     SYSCALL_FUNC( NtCompareTokens );
 190 }
 191
 192 NTSTATUS SYSCALL_API NtCompleteConnectPort( HANDLE handle )
 193 {
 194     SYSCALL_FUNC( NtCompleteConnectPort );
 195 }
 196
 197 NTSTATUS SYSCALL_API NtConnectPort( HANDLE *handle, UNICODE_STRING *name, SECURITY_QUALITY_OF_SERVICE *qos,
 198                                     LPC_SECTION_WRITE *write, LPC_SECTION_READ *read, ULONG *max_len,
 199                                     void *info, ULONG *info_len )
 200 {
 201     SYSCALL_FUNC( NtConnectPort );
 202 }
 203
 204 static NTSTATUS SYSCALL_API syscall_NtContinue( ARM64_NT_CONTEXT *context, BOOLEAN alertable )
 205 {
 206     __ASM_SYSCALL_FUNC( __id_NtContinue, syscall_NtContinue );
 207 }
 208
 209 NTSTATUS WINAPI NtContinue( CONTEXT *context, BOOLEAN alertable )
 210 {
 211     ARM64_NT_CONTEXT arm_ctx;
 212
 213     context_x64_to_arm( &arm_ctx, (ARM64EC_NT_CONTEXT *)context );
 214     return syscall_NtContinue( &arm_ctx, alertable );
 215 }
 216
 217 NTSTATUS SYSCALL_API NtCreateDebugObject( HANDLE *handle, ACCESS_MASK access,
 218                                           OBJECT_ATTRIBUTES *attr, ULONG flags )
 219 {
 220     SYSCALL_FUNC( NtCreateDebugObject );
 221 }
 222
 223 NTSTATUS SYSCALL_API NtCreateDirectoryObject( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr )
 224 {
 225     SYSCALL_FUNC( NtCreateDirectoryObject );
 226 }
 227
 228 NTSTATUS SYSCALL_API NtCreateEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 229                                     EVENT_TYPE type, BOOLEAN state )
 230 {
 231     SYSCALL_FUNC( NtCreateEvent );
 232 }
 233
 234 NTSTATUS SYSCALL_API NtCreateFile( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
 235                                    IO_STATUS_BLOCK *io, LARGE_INTEGER *alloc_size,
 236                                    ULONG attributes, ULONG sharing, ULONG disposition,
 237                                    ULONG options, void *ea_buffer, ULONG ea_length )
 238 {
 239     SYSCALL_FUNC( NtCreateFile );
 240 }
 241
 242 NTSTATUS SYSCALL_API NtCreateIoCompletion( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
 243                                            ULONG threads )
 244 {
 245     SYSCALL_FUNC( NtCreateIoCompletion );
 246 }
 247
 248 NTSTATUS SYSCALL_API NtCreateJobObject( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 249 {
 250     SYSCALL_FUNC( NtCreateJobObject );
 251 }
 252
 253 NTSTATUS SYSCALL_API NtCreateKey( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 254                                   ULONG index, const UNICODE_STRING *class, ULONG options, ULONG *dispos )
 255 {
 256     SYSCALL_FUNC( NtCreateKey );
 257 }
 258
 259 NTSTATUS SYSCALL_API NtCreateKeyTransacted( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 260                                             ULONG index, const UNICODE_STRING *class, ULONG options,
 261                                             HANDLE transacted, ULONG *dispos )
 262 {
 263     SYSCALL_FUNC( NtCreateKeyTransacted );
 264 }
 265
 266 NTSTATUS SYSCALL_API NtCreateKeyedEvent( HANDLE *handle, ACCESS_MASK access,
 267                                          const OBJECT_ATTRIBUTES *attr, ULONG flags )
 268 {
 269     SYSCALL_FUNC( NtCreateKeyedEvent );
 270 }
 271
 272 NTSTATUS SYSCALL_API NtCreateLowBoxToken( HANDLE *token_handle, HANDLE token, ACCESS_MASK access,
 273                                           OBJECT_ATTRIBUTES *attr, SID *sid, ULONG count,
 274                                           SID_AND_ATTRIBUTES *capabilities, ULONG handle_count,
 275                                           HANDLE *handle )
 276 {
 277     SYSCALL_FUNC( NtCreateLowBoxToken );
 278 }
 279
 280 NTSTATUS SYSCALL_API NtCreateMailslotFile( HANDLE *handle, ULONG access, OBJECT_ATTRIBUTES *attr,
 281                                            IO_STATUS_BLOCK *io, ULONG options, ULONG quota, ULONG msg_size,
 282                                            LARGE_INTEGER *timeout )
 283 {
 284     SYSCALL_FUNC( NtCreateMailslotFile );
 285 }
 286
 287 NTSTATUS SYSCALL_API NtCreateMutant( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 288                                      BOOLEAN owned )
 289 {
 290     SYSCALL_FUNC( NtCreateMutant );
 291 }
 292
 293 NTSTATUS SYSCALL_API NtCreateNamedPipeFile( HANDLE *handle, ULONG access, OBJECT_ATTRIBUTES *attr,
 294                                             IO_STATUS_BLOCK *io, ULONG sharing, ULONG dispo, ULONG options,
 295                                             ULONG pipe_type, ULONG read_mode, ULONG completion_mode,
 296                                             ULONG max_inst, ULONG inbound_quota, ULONG outbound_quota,
 297                                             LARGE_INTEGER *timeout )
 298 {
 299     SYSCALL_FUNC( NtCreateNamedPipeFile );
 300 }
 301
 302 NTSTATUS SYSCALL_API NtCreatePagingFile( UNICODE_STRING *name, LARGE_INTEGER *min_size,
 303                                          LARGE_INTEGER *max_size, LARGE_INTEGER *actual_size )
 304 {
 305     SYSCALL_FUNC( NtCreatePagingFile );
 306 }
 307
 308 NTSTATUS SYSCALL_API NtCreatePort( HANDLE *handle, OBJECT_ATTRIBUTES *attr, ULONG info_len,
 309                                    ULONG data_len, ULONG *reserved )
 310 {
 311     SYSCALL_FUNC( NtCreatePort );
 312 }
 313
 314 NTSTATUS SYSCALL_API NtCreateSection( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 315                                       const LARGE_INTEGER *size, ULONG protect,
 316                                       ULONG sec_flags, HANDLE file )
 317 {
 318     SYSCALL_FUNC( NtCreateSection );
 319 }
 320
 321 NTSTATUS SYSCALL_API NtCreateSemaphore( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 322                                         LONG initial, LONG max )
 323 {
 324     SYSCALL_FUNC( NtCreateSemaphore );
 325 }
 326
 327 NTSTATUS SYSCALL_API NtCreateSymbolicLinkObject( HANDLE *handle, ACCESS_MASK access,
 328                                                  OBJECT_ATTRIBUTES *attr, UNICODE_STRING *target )
 329 {
 330     SYSCALL_FUNC( NtCreateSymbolicLinkObject );
 331 }
 332
 333 NTSTATUS SYSCALL_API NtCreateThread( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
 334                                      HANDLE process, CLIENT_ID *id, CONTEXT *ctx, INITIAL_TEB *teb,
 335                                      BOOLEAN suspended )
 336 {
 337     SYSCALL_FUNC( NtCreateThread );
 338 }
 339
 340 NTSTATUS SYSCALL_API NtCreateThreadEx( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
 341                                        HANDLE process, PRTL_THREAD_START_ROUTINE start, void *param,
 342                                        ULONG flags, ULONG_PTR zero_bits, SIZE_T stack_commit,
 343                                        SIZE_T stack_reserve, PS_ATTRIBUTE_LIST *attr_list )
 344 {
 345     SYSCALL_FUNC( NtCreateThreadEx );
 346 }
 347
 348 NTSTATUS SYSCALL_API NtCreateTimer( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 349                                     TIMER_TYPE type )
 350 {
 351     SYSCALL_FUNC( NtCreateTimer );
 352 }
 353
 354 NTSTATUS SYSCALL_API NtCreateToken( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
 355                                     TOKEN_TYPE type, LUID *token_id, LARGE_INTEGER *expire,
 356                                     TOKEN_USER *user, TOKEN_GROUPS *groups, TOKEN_PRIVILEGES *privs,
 357                                     TOKEN_OWNER *owner, TOKEN_PRIMARY_GROUP *group,
 358                                     TOKEN_DEFAULT_DACL *dacl, TOKEN_SOURCE *source )
 359 {
 360     SYSCALL_FUNC( NtCreateToken );
 361 }
 362
 363 NTSTATUS SYSCALL_API NtCreateTransaction( HANDLE *handle, ACCESS_MASK mask, OBJECT_ATTRIBUTES *obj_attr,
 364                                           GUID *guid, HANDLE tm, ULONG options, ULONG isol_level,
 365                                           ULONG isol_flags, PLARGE_INTEGER timeout,
 366                                           UNICODE_STRING *description )
 367 {
 368     SYSCALL_FUNC( NtCreateTransaction );
 369 }
 370
 371 NTSTATUS SYSCALL_API NtCreateUserProcess( HANDLE *process_handle_ptr, HANDLE *thread_handle_ptr,
 372                                           ACCESS_MASK process_access, ACCESS_MASK thread_access,
 373                                           OBJECT_ATTRIBUTES *process_attr, OBJECT_ATTRIBUTES *thread_attr,
 374                                           ULONG process_flags, ULONG thread_flags,
 375                                           RTL_USER_PROCESS_PARAMETERS *params, PS_CREATE_INFO *info,
 376                                           PS_ATTRIBUTE_LIST *ps_attr )
 377 {
 378     SYSCALL_FUNC( NtCreateUserProcess );
 379 }
 380
 381 NTSTATUS SYSCALL_API NtDebugActiveProcess( HANDLE process, HANDLE debug )
 382 {
 383     SYSCALL_FUNC( NtDebugActiveProcess );
 384 }
 385
 386 NTSTATUS SYSCALL_API NtDebugContinue( HANDLE handle, CLIENT_ID *client, NTSTATUS status )
 387 {
 388     SYSCALL_FUNC( NtDebugContinue );
 389 }
 390
 391 NTSTATUS SYSCALL_API NtDelayExecution( BOOLEAN alertable, const LARGE_INTEGER *timeout )
 392 {
 393     SYSCALL_FUNC( NtDelayExecution );
 394 }
 395
 396 NTSTATUS SYSCALL_API NtDeleteAtom( RTL_ATOM atom )
 397 {
 398     SYSCALL_FUNC( NtDeleteAtom );
 399 }
 400
 401 NTSTATUS SYSCALL_API NtDeleteFile( OBJECT_ATTRIBUTES *attr )
 402 {
 403     SYSCALL_FUNC( NtDeleteFile );
 404 }
 405
 406 NTSTATUS SYSCALL_API NtDeleteKey( HANDLE key )
 407 {
 408     SYSCALL_FUNC( NtDeleteKey );
 409 }
 410
 411 NTSTATUS SYSCALL_API NtDeleteValueKey( HANDLE key, const UNICODE_STRING *name )
 412 {
 413     SYSCALL_FUNC( NtDeleteValueKey );
 414 }
 415
 416 NTSTATUS SYSCALL_API NtDeviceIoControlFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc,
 417                                             void *apc_context, IO_STATUS_BLOCK *io, ULONG code,
 418                                             void *in_buffer, ULONG in_size,
 419                                             void *out_buffer, ULONG out_size )
 420 {
 421     SYSCALL_FUNC( NtDeviceIoControlFile );
 422 }
 423
 424 NTSTATUS SYSCALL_API NtDisplayString( UNICODE_STRING *string )
 425 {
 426     SYSCALL_FUNC( NtDisplayString );
 427 }
 428
 429 NTSTATUS SYSCALL_API NtDuplicateObject( HANDLE source_process, HANDLE source, HANDLE dest_process,
 430                                         HANDLE *dest, ACCESS_MASK access, ULONG attributes, ULONG options )
 431 {
 432     SYSCALL_FUNC( NtDuplicateObject );
 433 }
 434
 435 NTSTATUS SYSCALL_API NtDuplicateToken( HANDLE token, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
 436                                        BOOLEAN effective_only, TOKEN_TYPE type, HANDLE *handle )
 437 {
 438     SYSCALL_FUNC( NtDuplicateToken );
 439 }
 440
 441 NTSTATUS SYSCALL_API NtEnumerateKey( HANDLE handle, ULONG index, KEY_INFORMATION_CLASS info_class,
 442                                      void *info, DWORD length, DWORD *result_len )
 443 {
 444     SYSCALL_FUNC( NtEnumerateKey );
 445 }
 446
 447 NTSTATUS SYSCALL_API NtEnumerateValueKey( HANDLE handle, ULONG index, KEY_VALUE_INFORMATION_CLASS info_class,
 448                                           void *info, DWORD length, DWORD *result_len )
 449 {
 450     SYSCALL_FUNC( NtEnumerateValueKey );
 451 }
 452
 453 NTSTATUS SYSCALL_API NtFilterToken( HANDLE token, ULONG flags, TOKEN_GROUPS *disable_sids,
 454                                     TOKEN_PRIVILEGES *privileges, TOKEN_GROUPS *restrict_sids,
 455                                     HANDLE *new_token )
 456 {
 457     SYSCALL_FUNC( NtFilterToken );
 458 }
 459
 460 NTSTATUS SYSCALL_API NtFindAtom( const WCHAR *name, ULONG length, RTL_ATOM *atom )
 461 {
 462     SYSCALL_FUNC( NtFindAtom );
 463 }
 464
 465 NTSTATUS SYSCALL_API NtFlushBuffersFile( HANDLE handle, IO_STATUS_BLOCK *io )
 466 {
 467     SYSCALL_FUNC( NtFlushBuffersFile );
 468 }
 469
 470 NTSTATUS SYSCALL_API NtFlushInstructionCache( HANDLE handle, const void *addr, SIZE_T size )
 471 {
 472     SYSCALL_FUNC( NtFlushInstructionCache );
 473 }
 474
 475 NTSTATUS SYSCALL_API NtFlushKey( HANDLE key )
 476 {
 477     SYSCALL_FUNC( NtFlushKey );
 478 }
 479
 480 NTSTATUS SYSCALL_API NtFlushProcessWriteBuffers(void)
 481 {
 482     SYSCALL_FUNC( NtFlushProcessWriteBuffers );
 483 }
 484
 485 NTSTATUS SYSCALL_API NtFlushVirtualMemory( HANDLE process, LPCVOID *addr_ptr,
 486                                            SIZE_T *size_ptr, ULONG unknown )
 487 {
 488     SYSCALL_FUNC( NtFlushVirtualMemory );
 489 }
 490
 491 NTSTATUS SYSCALL_API NtFreeVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *size_ptr, ULONG type )
 492 {
 493     SYSCALL_FUNC( NtFreeVirtualMemory );
 494 }
 495
 496 NTSTATUS SYSCALL_API NtFsControlFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_context,
 497                                       IO_STATUS_BLOCK *io, ULONG code, void *in_buffer, ULONG in_size,
 498                                       void *out_buffer, ULONG out_size )
 499 {
 500     SYSCALL_FUNC( NtFsControlFile );
 501 }
 502
 503 static NTSTATUS SYSCALL_API syscall_NtGetContextThread( HANDLE handle, ARM64_NT_CONTEXT *context )
 504 {
 505     __ASM_SYSCALL_FUNC( __id_NtGetContextThread, syscall_NtGetContextThread );
 506 }
 507
 508 NTSTATUS WINAPI NtGetContextThread( HANDLE handle, CONTEXT *context )
 509 {
 510     ARM64_NT_CONTEXT arm_ctx = { .ContextFlags = ctx_flags_x64_to_arm( context->ContextFlags ) };
 511     NTSTATUS status = syscall_NtGetContextThread( handle, &arm_ctx );
 512
 513     if (!status) context_arm_to_x64( (ARM64EC_NT_CONTEXT *)context, &arm_ctx );
 514     return status;
 515 }
 516
 517 ULONG SYSCALL_API NtGetCurrentProcessorNumber(void)
 518 {
 519     SYSCALL_FUNC( NtGetCurrentProcessorNumber );
 520 }
 521
 522 NTSTATUS SYSCALL_API NtGetNextThread( HANDLE process, HANDLE thread, ACCESS_MASK access, ULONG attributes,
 523                                       ULONG flags, HANDLE *handle )
 524 {
 525     SYSCALL_FUNC( NtGetNextThread );
 526 }
 527
 528 NTSTATUS SYSCALL_API NtGetNlsSectionPtr( ULONG type, ULONG id, void *unknown, void **ptr, SIZE_T *size )
 529 {
 530     SYSCALL_FUNC( NtGetNlsSectionPtr );
 531 }
 532
 533 NTSTATUS SYSCALL_API NtGetWriteWatch( HANDLE process, ULONG flags, PVOID base, SIZE_T size,
 534                                       PVOID *addresses, ULONG_PTR *count, ULONG *granularity )
 535 {
 536     SYSCALL_FUNC( NtGetWriteWatch );
 537 }
 538
 539 NTSTATUS SYSCALL_API NtImpersonateAnonymousToken( HANDLE thread )
 540 {
 541     SYSCALL_FUNC( NtImpersonateAnonymousToken );
 542 }
 543
 544 NTSTATUS SYSCALL_API NtInitializeNlsFiles( void **ptr, LCID *lcid, LARGE_INTEGER *size )
 545 {
 546     SYSCALL_FUNC( NtInitializeNlsFiles );
 547 }
 548
 549 NTSTATUS SYSCALL_API NtInitiatePowerAction( POWER_ACTION action, SYSTEM_POWER_STATE state,
 550                                             ULONG flags, BOOLEAN async )
 551 {
 552     SYSCALL_FUNC( NtInitiatePowerAction );
 553 }
 554
 555 NTSTATUS SYSCALL_API NtIsProcessInJob( HANDLE process, HANDLE job )
 556 {
 557     SYSCALL_FUNC( NtIsProcessInJob );
 558 }
 559
 560 NTSTATUS SYSCALL_API NtListenPort( HANDLE handle, LPC_MESSAGE *msg )
 561 {
 562     SYSCALL_FUNC( NtListenPort );
 563 }
 564
 565 NTSTATUS SYSCALL_API NtLoadDriver( const UNICODE_STRING *name )
 566 {
 567     SYSCALL_FUNC( NtLoadDriver );
 568 }
 569
 570 NTSTATUS SYSCALL_API NtLoadKey( const OBJECT_ATTRIBUTES *attr, OBJECT_ATTRIBUTES *file )
 571 {
 572     SYSCALL_FUNC( NtLoadKey );
 573 }
 574
 575 NTSTATUS SYSCALL_API NtLoadKey2( const OBJECT_ATTRIBUTES *attr, OBJECT_ATTRIBUTES *file, ULONG flags )
 576 {
 577     SYSCALL_FUNC( NtLoadKey2 );
 578 }
 579
 580 NTSTATUS SYSCALL_API NtLoadKeyEx( const OBJECT_ATTRIBUTES *attr, OBJECT_ATTRIBUTES *file, ULONG flags,
 581                                   HANDLE trustkey, HANDLE event, ACCESS_MASK access,
 582                                   HANDLE *roothandle, IO_STATUS_BLOCK *iostatus )
 583 {
 584     SYSCALL_FUNC( NtLoadKeyEx );
 585 }
 586
 587 NTSTATUS SYSCALL_API NtLockFile( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc, void* apc_user,
 588                                  IO_STATUS_BLOCK *io_status, LARGE_INTEGER *offset,
 589                                  LARGE_INTEGER *count, ULONG *key, BOOLEAN dont_wait, BOOLEAN exclusive )
 590 {
 591     SYSCALL_FUNC( NtLockFile );
 592 }
 593
 594 NTSTATUS SYSCALL_API NtLockVirtualMemory( HANDLE process, PVOID *addr, SIZE_T *size, ULONG unknown )
 595 {
 596     SYSCALL_FUNC( NtLockVirtualMemory );
 597 }
 598
 599 NTSTATUS SYSCALL_API NtMakeTemporaryObject( HANDLE handle )
 600 {
 601     SYSCALL_FUNC( NtMakeTemporaryObject );
 602 }
 603
 604 NTSTATUS SYSCALL_API NtMapViewOfSection( HANDLE handle, HANDLE process, PVOID *addr_ptr,
 605                                          ULONG_PTR zero_bits, SIZE_T commit_size,
 606                                          const LARGE_INTEGER *offset_ptr, SIZE_T *size_ptr,
 607                                          SECTION_INHERIT inherit, ULONG alloc_type, ULONG protect )
 608 {
 609     SYSCALL_FUNC( NtMapViewOfSection );
 610 }
 611
 612 NTSTATUS SYSCALL_API NtMapViewOfSectionEx( HANDLE handle, HANDLE process, PVOID *addr_ptr,
 613                                            const LARGE_INTEGER *offset_ptr, SIZE_T *size_ptr,
 614                                            ULONG alloc_type, ULONG protect,
 615                                            MEM_EXTENDED_PARAMETER *parameters, ULONG count )
 616 {
 617     SYSCALL_FUNC( NtMapViewOfSectionEx );
 618 }
 619
 620 NTSTATUS SYSCALL_API NtNotifyChangeDirectoryFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc,
 621                                                   void *apc_context, IO_STATUS_BLOCK *iosb, void *buffer,
 622                                                   ULONG buffer_size, ULONG filter, BOOLEAN subtree )
 623 {
 624     SYSCALL_FUNC( NtNotifyChangeDirectoryFile );
 625 }
 626
 627 NTSTATUS SYSCALL_API NtNotifyChangeKey( HANDLE key, HANDLE event, PIO_APC_ROUTINE apc, void *apc_context,
 628                                         IO_STATUS_BLOCK *io, ULONG filter, BOOLEAN subtree,
 629                                         void *buffer, ULONG length, BOOLEAN async )
 630 {
 631     SYSCALL_FUNC( NtNotifyChangeKey );
 632 }
 633
 634 NTSTATUS SYSCALL_API NtNotifyChangeMultipleKeys( HANDLE key, ULONG count, OBJECT_ATTRIBUTES *attr,
 635                                                  HANDLE event, PIO_APC_ROUTINE apc, void *apc_context,
 636                                                  IO_STATUS_BLOCK *io, ULONG filter, BOOLEAN subtree,
 637                                                  void *buffer, ULONG length, BOOLEAN async )
 638 {
 639     SYSCALL_FUNC( NtNotifyChangeMultipleKeys );
 640 }
 641
 642 NTSTATUS SYSCALL_API NtOpenDirectoryObject( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 643 {
 644     SYSCALL_FUNC( NtOpenDirectoryObject );
 645 }
 646
 647 NTSTATUS SYSCALL_API NtOpenEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 648 {
 649     SYSCALL_FUNC( NtOpenEvent );
 650 }
 651
 652 NTSTATUS SYSCALL_API NtOpenFile( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
 653                                  IO_STATUS_BLOCK *io, ULONG sharing, ULONG options )
 654 {
 655     SYSCALL_FUNC( NtOpenFile );
 656 }
 657
 658 NTSTATUS SYSCALL_API NtOpenIoCompletion( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 659 {
 660     SYSCALL_FUNC( NtOpenIoCompletion );
 661 }
 662
 663 NTSTATUS SYSCALL_API NtOpenJobObject( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 664 {
 665     SYSCALL_FUNC( NtOpenJobObject );
 666 }
 667
 668 NTSTATUS SYSCALL_API NtOpenKey( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 669 {
 670     SYSCALL_FUNC( NtOpenKey );
 671 }
 672
 673 NTSTATUS SYSCALL_API NtOpenKeyEx( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr, ULONG options )
 674 {
 675     SYSCALL_FUNC( NtOpenKeyEx );
 676 }
 677
 678 NTSTATUS SYSCALL_API NtOpenKeyTransacted( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 679                                           HANDLE transaction )
 680 {
 681     SYSCALL_FUNC( NtOpenKeyTransacted );
 682 }
 683
 684 NTSTATUS SYSCALL_API NtOpenKeyTransactedEx( HANDLE *key, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr,
 685                                             ULONG options, HANDLE transaction )
 686 {
 687     SYSCALL_FUNC( NtOpenKeyTransactedEx );
 688 }
 689
 690 NTSTATUS SYSCALL_API NtOpenKeyedEvent( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 691 {
 692     SYSCALL_FUNC( NtOpenKeyedEvent );
 693 }
 694
 695 NTSTATUS SYSCALL_API NtOpenMutant( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 696 {
 697     SYSCALL_FUNC( NtOpenMutant );
 698 }
 699
 700 NTSTATUS SYSCALL_API NtOpenProcess( HANDLE *handle, ACCESS_MASK access,
 701                                     const OBJECT_ATTRIBUTES *attr, const CLIENT_ID *id )
 702 {
 703     SYSCALL_FUNC( NtOpenProcess );
 704 }
 705
 706 NTSTATUS SYSCALL_API NtOpenProcessToken( HANDLE process, DWORD access, HANDLE *handle )
 707 {
 708     SYSCALL_FUNC( NtOpenProcessToken );
 709 }
 710
 711 NTSTATUS SYSCALL_API NtOpenProcessTokenEx( HANDLE process, DWORD access, DWORD attributes, HANDLE *handle )
 712 {
 713     SYSCALL_FUNC( NtOpenProcessTokenEx );
 714 }
 715
 716 NTSTATUS SYSCALL_API NtOpenSection( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 717 {
 718     SYSCALL_FUNC( NtOpenSection );
 719 }
 720
 721 NTSTATUS SYSCALL_API NtOpenSemaphore( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 722 {
 723     SYSCALL_FUNC( NtOpenSemaphore );
 724 }
 725
 726 NTSTATUS SYSCALL_API NtOpenSymbolicLinkObject( HANDLE *handle, ACCESS_MASK access,
 727                                                const OBJECT_ATTRIBUTES *attr )
 728 {
 729     SYSCALL_FUNC( NtOpenSymbolicLinkObject );
 730 }
 731
 732 NTSTATUS SYSCALL_API NtOpenThread( HANDLE *handle, ACCESS_MASK access,
 733                                    const OBJECT_ATTRIBUTES *attr, const CLIENT_ID *id )
 734 {
 735     SYSCALL_FUNC( NtOpenThread );
 736 }
 737
 738 NTSTATUS SYSCALL_API NtOpenThreadToken( HANDLE thread, DWORD access, BOOLEAN self, HANDLE *handle )
 739 {
 740     SYSCALL_FUNC( NtOpenThreadToken );
 741 }
 742
 743 NTSTATUS SYSCALL_API NtOpenThreadTokenEx( HANDLE thread, DWORD access, BOOLEAN self, DWORD attributes,
 744                                           HANDLE *handle )
 745 {
 746     SYSCALL_FUNC( NtOpenThreadTokenEx );
 747 }
 748
 749 NTSTATUS SYSCALL_API NtOpenTimer( HANDLE *handle, ACCESS_MASK access, const OBJECT_ATTRIBUTES *attr )
 750 {
 751     SYSCALL_FUNC( NtOpenTimer );
 752 }
 753
 754 NTSTATUS SYSCALL_API NtPowerInformation( POWER_INFORMATION_LEVEL level, void *input, ULONG in_size,
 755                                          void *output, ULONG out_size )
 756 {
 757     SYSCALL_FUNC( NtPowerInformation );
 758 }
 759
 760 NTSTATUS SYSCALL_API NtPrivilegeCheck( HANDLE token, PRIVILEGE_SET *privs, BOOLEAN *res )
 761 {
 762     SYSCALL_FUNC( NtPrivilegeCheck );
 763 }
 764
 765 NTSTATUS SYSCALL_API NtProtectVirtualMemory( HANDLE process, PVOID *addr_ptr, SIZE_T *size_ptr,
 766                                              ULONG new_prot, ULONG *old_prot )
 767 {
 768     SYSCALL_FUNC( NtProtectVirtualMemory );
 769 }
 770
 771 NTSTATUS SYSCALL_API NtPulseEvent( HANDLE handle, LONG *prev_state )
 772 {
 773     SYSCALL_FUNC( NtPulseEvent );
 774 }
 775
 776 NTSTATUS SYSCALL_API NtQueryAttributesFile( const OBJECT_ATTRIBUTES *attr, FILE_BASIC_INFORMATION *info )
 777 {
 778     SYSCALL_FUNC( NtQueryAttributesFile );
 779 }
 780
 781 NTSTATUS SYSCALL_API NtQueryDefaultLocale( BOOLEAN user, LCID *lcid )
 782 {
 783     SYSCALL_FUNC( NtQueryDefaultLocale );
 784 }
 785
 786 NTSTATUS SYSCALL_API NtQueryDefaultUILanguage( LANGID *lang )
 787 {
 788     SYSCALL_FUNC( NtQueryDefaultUILanguage );
 789 }
 790
 791 NTSTATUS SYSCALL_API NtQueryDirectoryFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc_routine,
 792                                            void *apc_context, IO_STATUS_BLOCK *io, void *buffer,
 793                                            ULONG length, FILE_INFORMATION_CLASS info_class,
 794                                            BOOLEAN single_entry, UNICODE_STRING *mask,
 795                                            BOOLEAN restart_scan )
 796 {
 797     SYSCALL_FUNC( NtQueryDirectoryFile );
 798 }
 799
 800 NTSTATUS SYSCALL_API NtQueryDirectoryObject( HANDLE handle, DIRECTORY_BASIC_INFORMATION *buffer,
 801                                              ULONG size, BOOLEAN single_entry, BOOLEAN restart,
 802                                              ULONG *context, ULONG *ret_size )
 803 {
 804     SYSCALL_FUNC( NtQueryDirectoryObject );
 805 }
 806
 807 NTSTATUS SYSCALL_API NtQueryEaFile( HANDLE handle, IO_STATUS_BLOCK *io, void *buffer, ULONG length,
 808                                     BOOLEAN single_entry, void *list, ULONG list_len,
 809                                     ULONG *index, BOOLEAN restart )
 810 {
 811     SYSCALL_FUNC( NtQueryEaFile );
 812 }
 813
 814 NTSTATUS SYSCALL_API NtQueryEvent( HANDLE handle, EVENT_INFORMATION_CLASS class,
 815                                    void *info, ULONG len, ULONG *ret_len )
 816 {
 817     SYSCALL_FUNC( NtQueryEvent );
 818 }
 819
 820 NTSTATUS SYSCALL_API NtQueryFullAttributesFile( const OBJECT_ATTRIBUTES *attr,
 821                                                 FILE_NETWORK_OPEN_INFORMATION *info )
 822 {
 823     SYSCALL_FUNC( NtQueryFullAttributesFile );
 824 }
 825
 826 NTSTATUS SYSCALL_API NtQueryInformationAtom( RTL_ATOM atom, ATOM_INFORMATION_CLASS class,
 827                                              void *ptr, ULONG size, ULONG *retsize )
 828 {
 829     SYSCALL_FUNC( NtQueryInformationAtom );
 830 }
 831
 832 NTSTATUS SYSCALL_API NtQueryInformationFile( HANDLE handle, IO_STATUS_BLOCK *io,
 833                                              void *ptr, ULONG len, FILE_INFORMATION_CLASS class )
 834 {
 835     SYSCALL_FUNC( NtQueryInformationFile );
 836 }
 837
 838 NTSTATUS SYSCALL_API NtQueryInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, void *info,
 839                                                   ULONG len, ULONG *ret_len )
 840 {
 841     SYSCALL_FUNC( NtQueryInformationJobObject );
 842 }
 843
 844 NTSTATUS SYSCALL_API NtQueryInformationProcess( HANDLE handle, PROCESSINFOCLASS class, void *info,
 845                                                 ULONG size, ULONG *ret_len )
 846 {
 847     SYSCALL_FUNC( NtQueryInformationProcess );
 848 }
 849
 850 NTSTATUS SYSCALL_API NtQueryInformationThread( HANDLE handle, THREADINFOCLASS class,
 851                                                void *data, ULONG length, ULONG *ret_len )
 852 {
 853     SYSCALL_FUNC( NtQueryInformationThread );
 854 }
 855
 856 NTSTATUS SYSCALL_API NtQueryInformationToken( HANDLE token, TOKEN_INFORMATION_CLASS class,
 857                                               void *info, ULONG length, ULONG *retlen )
 858 {
 859     SYSCALL_FUNC( NtQueryInformationToken );
 860 }
 861
 862 NTSTATUS SYSCALL_API NtQueryInstallUILanguage( LANGID *lang )
 863 {
 864     SYSCALL_FUNC( NtQueryInstallUILanguage );
 865 }
 866
 867 NTSTATUS SYSCALL_API NtQueryIoCompletion( HANDLE handle, IO_COMPLETION_INFORMATION_CLASS class,
 868                                           void *buffer, ULONG len, ULONG *ret_len )
 869 {
 870     SYSCALL_FUNC( NtQueryIoCompletion );
 871 }
 872
 873 NTSTATUS SYSCALL_API NtQueryKey( HANDLE handle, KEY_INFORMATION_CLASS info_class,
 874                                  void *info, DWORD length, DWORD *result_len )
 875 {
 876     SYSCALL_FUNC( NtQueryKey );
 877 }
 878
 879 NTSTATUS SYSCALL_API NtQueryLicenseValue( const UNICODE_STRING *name, ULONG *type,
 880                                           void *data, ULONG length, ULONG *retlen )
 881 {
 882     SYSCALL_FUNC( NtQueryLicenseValue );
 883 }
 884
 885 NTSTATUS SYSCALL_API NtQueryMultipleValueKey( HANDLE key, KEY_MULTIPLE_VALUE_INFORMATION *info,
 886                                               ULONG count, void *buffer, ULONG length, ULONG *retlen )
 887 {
 888     SYSCALL_FUNC( NtQueryMultipleValueKey );
 889 }
 890
 891 NTSTATUS SYSCALL_API NtQueryMutant( HANDLE handle, MUTANT_INFORMATION_CLASS class,
 892                                     void *info, ULONG len, ULONG *ret_len )
 893 {
 894     SYSCALL_FUNC( NtQueryMutant );
 895 }
 896
 897 NTSTATUS SYSCALL_API NtQueryObject( HANDLE handle, OBJECT_INFORMATION_CLASS info_class,
 898                                     void *ptr, ULONG len, ULONG *used_len )
 899 {
 900     SYSCALL_FUNC( NtQueryObject );
 901 }
 902
 903 NTSTATUS SYSCALL_API NtQueryPerformanceCounter( LARGE_INTEGER *counter, LARGE_INTEGER *frequency )
 904 {
 905     SYSCALL_FUNC( NtQueryPerformanceCounter );
 906 }
 907
 908 NTSTATUS SYSCALL_API NtQuerySection( HANDLE handle, SECTION_INFORMATION_CLASS class, void *ptr,
 909                                      SIZE_T size, SIZE_T *ret_size )
 910 {
 911     SYSCALL_FUNC( NtQuerySection );
 912 }
 913
 914 NTSTATUS SYSCALL_API NtQuerySecurityObject( HANDLE handle, SECURITY_INFORMATION info,
 915                                             PSECURITY_DESCRIPTOR descr, ULONG length, ULONG *retlen )
 916 {
 917     SYSCALL_FUNC( NtQuerySecurityObject );
 918 }
 919
 920 NTSTATUS SYSCALL_API NtQuerySemaphore( HANDLE handle, SEMAPHORE_INFORMATION_CLASS class,
 921                                        void *info, ULONG len, ULONG *ret_len )
 922 {
 923     SYSCALL_FUNC( NtQuerySemaphore );
 924 }
 925
 926 NTSTATUS SYSCALL_API NtQuerySymbolicLinkObject( HANDLE handle, UNICODE_STRING *target, ULONG *length )
 927 {
 928     SYSCALL_FUNC( NtQuerySymbolicLinkObject );
 929 }
 930
 931 NTSTATUS SYSCALL_API NtQuerySystemEnvironmentValue( UNICODE_STRING *name, WCHAR *buffer, ULONG length,
 932                                                     ULONG *retlen )
 933 {
 934     SYSCALL_FUNC( NtQuerySystemEnvironmentValue );
 935 }
 936
 937 NTSTATUS SYSCALL_API NtQuerySystemEnvironmentValueEx( UNICODE_STRING *name, GUID *vendor, void *buffer,
 938                                                       ULONG *retlen, ULONG *attrib )
 939 {
 940     SYSCALL_FUNC( NtQuerySystemEnvironmentValueEx );
 941 }
 942
 943 NTSTATUS SYSCALL_API NtQuerySystemInformation( SYSTEM_INFORMATION_CLASS class,
 944                                                void *info, ULONG size, ULONG *ret_size )
 945 {
 946     SYSCALL_FUNC( NtQuerySystemInformation );
 947 }
 948
 949 NTSTATUS SYSCALL_API NtQuerySystemInformationEx( SYSTEM_INFORMATION_CLASS class, void *query,
 950                                                  ULONG query_len, void *info, ULONG size, ULONG *ret_size )
 951 {
 952     SYSCALL_FUNC( NtQuerySystemInformationEx );
 953 }
 954
 955 NTSTATUS SYSCALL_API NtQuerySystemTime( LARGE_INTEGER *time )
 956 {
 957     SYSCALL_FUNC( NtQuerySystemTime );
 958 }
 959
 960 NTSTATUS SYSCALL_API NtQueryTimer( HANDLE handle, TIMER_INFORMATION_CLASS class,
 961                                    void *info, ULONG len, ULONG *ret_len )
 962 {
 963     SYSCALL_FUNC( NtQueryTimer );
 964 }
 965
 966 NTSTATUS SYSCALL_API NtQueryTimerResolution( ULONG *min_res, ULONG *max_res, ULONG *current_res )
 967 {
 968     SYSCALL_FUNC( NtQueryTimerResolution );
 969 }
 970
 971 NTSTATUS SYSCALL_API NtQueryValueKey( HANDLE handle, const UNICODE_STRING *name,
 972                                       KEY_VALUE_INFORMATION_CLASS info_class,
 973                                       void *info, DWORD length, DWORD *result_len )
 974 {
 975     SYSCALL_FUNC( NtQueryValueKey );
 976 }
 977
 978 NTSTATUS SYSCALL_API NtQueryVirtualMemory( HANDLE process, LPCVOID addr, MEMORY_INFORMATION_CLASS info_class,
 979                                            PVOID buffer, SIZE_T len, SIZE_T *res_len )
 980 {
 981     SYSCALL_FUNC( NtQueryVirtualMemory );
 982 }
 983
 984 NTSTATUS SYSCALL_API NtQueryVolumeInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, void *buffer,
 985                                                    ULONG length, FS_INFORMATION_CLASS info_class )
 986 {
 987     SYSCALL_FUNC( NtQueryVolumeInformationFile );
 988 }
 989
 990 NTSTATUS SYSCALL_API NtQueueApcThread( HANDLE handle, PNTAPCFUNC func, ULONG_PTR arg1,
 991                                        ULONG_PTR arg2, ULONG_PTR arg3 )
 992 {
 993     SYSCALL_FUNC( NtQueueApcThread );
 994 }
 995
 996 static NTSTATUS SYSCALL_API syscall_NtRaiseException( EXCEPTION_RECORD *rec, ARM64_NT_CONTEXT *context, BOOL first_chance )
 997 {
 998     __ASM_SYSCALL_FUNC( __id_NtRaiseException, syscall_NtRaiseException );
 999 }
1000
1001 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
1002 {
1003     ARM64_NT_CONTEXT arm_ctx;
1004
1005     context_x64_to_arm( &arm_ctx, (ARM64EC_NT_CONTEXT *)context );
1006     return syscall_NtRaiseException( rec, &arm_ctx, first_chance );
1007 }
1008
1009 NTSTATUS SYSCALL_API NtRaiseHardError( NTSTATUS status, ULONG count, UNICODE_STRING *params_mask,
1010                                        void **params, HARDERROR_RESPONSE_OPTION option,
1011                                        HARDERROR_RESPONSE *response )
1012 {
1013     SYSCALL_FUNC( NtRaiseHardError );
1014 }
1015
1016 NTSTATUS SYSCALL_API NtReadFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
1017                                  IO_STATUS_BLOCK *io, void *buffer, ULONG length,
1018                                  LARGE_INTEGER *offset, ULONG *key )
1019 {
1020     SYSCALL_FUNC( NtReadFile );
1021 }
1022
1023 NTSTATUS SYSCALL_API NtReadFileScatter( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
1024                                         IO_STATUS_BLOCK *io, FILE_SEGMENT_ELEMENT *segments,
1025                                         ULONG length, LARGE_INTEGER *offset, ULONG *key )
1026 {
1027     SYSCALL_FUNC( NtReadFileScatter );
1028 }
1029
1030 NTSTATUS SYSCALL_API NtReadVirtualMemory( HANDLE process, const void *addr, void *buffer,
1031                                           SIZE_T size, SIZE_T *bytes_read )
1032 {
1033     SYSCALL_FUNC( NtReadVirtualMemory );
1034 }
1035
1036 NTSTATUS SYSCALL_API NtRegisterThreadTerminatePort( HANDLE handle )
1037 {
1038     SYSCALL_FUNC( NtRegisterThreadTerminatePort );
1039 }
1040
1041 NTSTATUS SYSCALL_API NtReleaseKeyedEvent( HANDLE handle, const void *key,
1042                                           BOOLEAN alertable, const LARGE_INTEGER *timeout )
1043 {
1044     SYSCALL_FUNC( NtReleaseKeyedEvent );
1045 }
1046
1047 NTSTATUS SYSCALL_API NtReleaseMutant( HANDLE handle, LONG *prev_count )
1048 {
1049     SYSCALL_FUNC( NtReleaseMutant );
1050 }
1051
1052 NTSTATUS SYSCALL_API NtReleaseSemaphore( HANDLE handle, ULONG count, ULONG *previous )
1053 {
1054     SYSCALL_FUNC( NtReleaseSemaphore );
1055 }
1056
1057 NTSTATUS SYSCALL_API NtRemoveIoCompletion( HANDLE handle, ULONG_PTR *key, ULONG_PTR *value,
1058                                            IO_STATUS_BLOCK *io, LARGE_INTEGER *timeout )
1059 {
1060     SYSCALL_FUNC( NtRemoveIoCompletion );
1061 }
1062
1063 NTSTATUS SYSCALL_API NtRemoveIoCompletionEx( HANDLE handle, FILE_IO_COMPLETION_INFORMATION *info,
1064                                              ULONG count, ULONG *written, LARGE_INTEGER *timeout,
1065                                              BOOLEAN alertable )
1066 {
1067     SYSCALL_FUNC( NtRemoveIoCompletionEx );
1068 }
1069
1070 NTSTATUS SYSCALL_API NtRemoveProcessDebug( HANDLE process, HANDLE debug )
1071 {
1072     SYSCALL_FUNC( NtRemoveProcessDebug );
1073 }
1074
1075 NTSTATUS SYSCALL_API NtRenameKey( HANDLE key, UNICODE_STRING *name )
1076 {
1077     SYSCALL_FUNC( NtRenameKey );
1078 }
1079
1080 NTSTATUS SYSCALL_API NtReplaceKey( OBJECT_ATTRIBUTES *attr, HANDLE key, OBJECT_ATTRIBUTES *replace )
1081 {
1082     SYSCALL_FUNC( NtReplaceKey );
1083 }
1084
1085 NTSTATUS SYSCALL_API NtReplyWaitReceivePort( HANDLE handle, ULONG *id, LPC_MESSAGE *reply, LPC_MESSAGE *msg )
1086 {
1087     SYSCALL_FUNC( NtReplyWaitReceivePort );
1088 }
1089
1090 NTSTATUS SYSCALL_API NtRequestWaitReplyPort( HANDLE handle, LPC_MESSAGE *msg_in, LPC_MESSAGE *msg_out )
1091 {
1092     SYSCALL_FUNC( NtRequestWaitReplyPort );
1093 }
1094
1095 NTSTATUS SYSCALL_API NtResetEvent( HANDLE handle, LONG *prev_state )
1096 {
1097     SYSCALL_FUNC( NtResetEvent );
1098 }
1099
1100 NTSTATUS SYSCALL_API NtResetWriteWatch( HANDLE process, PVOID base, SIZE_T size )
1101 {
1102     SYSCALL_FUNC( NtResetWriteWatch );
1103 }
1104
1105 NTSTATUS SYSCALL_API NtRestoreKey( HANDLE key, HANDLE file, ULONG flags )
1106 {
1107     SYSCALL_FUNC( NtRestoreKey );
1108 }
1109
1110 NTSTATUS SYSCALL_API NtResumeProcess( HANDLE handle )
1111 {
1112     SYSCALL_FUNC( NtResumeProcess );
1113 }
1114
1115 NTSTATUS SYSCALL_API NtResumeThread( HANDLE handle, ULONG *count )
1116 {
1117     SYSCALL_FUNC( NtResumeThread );
1118 }
1119
1120 NTSTATUS SYSCALL_API NtRollbackTransaction( HANDLE transaction, BOOLEAN wait )
1121 {
1122     SYSCALL_FUNC( NtRollbackTransaction );
1123 }
1124
1125 NTSTATUS SYSCALL_API NtSaveKey( HANDLE key, HANDLE file )
1126 {
1127     SYSCALL_FUNC( NtSaveKey );
1128 }
1129
1130 NTSTATUS SYSCALL_API NtSecureConnectPort( HANDLE *handle, UNICODE_STRING *name,
1131                                           SECURITY_QUALITY_OF_SERVICE *qos, LPC_SECTION_WRITE *write,
1132                                           PSID sid, LPC_SECTION_READ *read, ULONG *max_len,
1133                                           void *info, ULONG *info_len )
1134 {
1135     SYSCALL_FUNC( NtSecureConnectPort );
1136 }
1137
1138 static NTSTATUS SYSCALL_API syscall_NtSetContextThread( HANDLE handle, const ARM64_NT_CONTEXT *context )
1139 {
1140     __ASM_SYSCALL_FUNC( __id_NtSetContextThread, syscall_NtSetContextThread );
1141 }
1142
1143 NTSTATUS WINAPI NtSetContextThread( HANDLE handle, const CONTEXT *context )
1144 {
1145     ARM64_NT_CONTEXT arm_ctx;
1146
1147     context_x64_to_arm( &arm_ctx, (ARM64EC_NT_CONTEXT *)context );
1148     return syscall_NtSetContextThread( handle, &arm_ctx );
1149 }
1150
1151 NTSTATUS SYSCALL_API NtSetDebugFilterState( ULONG component_id, ULONG level, BOOLEAN state )
1152 {
1153     SYSCALL_FUNC( NtSetDebugFilterState );
1154 }
1155
1156 NTSTATUS SYSCALL_API NtSetDefaultLocale( BOOLEAN user, LCID lcid )
1157 {
1158     SYSCALL_FUNC( NtSetDefaultLocale );
1159 }
1160
1161 NTSTATUS SYSCALL_API NtSetDefaultUILanguage( LANGID lang )
1162 {
1163     SYSCALL_FUNC( NtSetDefaultUILanguage );
1164 }
1165
1166 NTSTATUS SYSCALL_API NtSetEaFile( HANDLE handle, IO_STATUS_BLOCK *io, void *buffer, ULONG length )
1167 {
1168     SYSCALL_FUNC( NtSetEaFile );
1169 }
1170
1171 NTSTATUS SYSCALL_API NtSetEvent( HANDLE handle, LONG *prev_state )
1172 {
1173     SYSCALL_FUNC( NtSetEvent );
1174 }
1175
1176 NTSTATUS SYSCALL_API NtSetInformationDebugObject( HANDLE handle, DEBUGOBJECTINFOCLASS class,
1177                                                   void *info, ULONG len, ULONG *ret_len )
1178 {
1179     SYSCALL_FUNC( NtSetInformationDebugObject );
1180 }
1181
1182 NTSTATUS SYSCALL_API NtSetInformationFile( HANDLE handle, IO_STATUS_BLOCK *io,
1183                                            void *ptr, ULONG len, FILE_INFORMATION_CLASS class )
1184 {
1185     SYSCALL_FUNC( NtSetInformationFile );
1186 }
1187
1188 NTSTATUS SYSCALL_API NtSetInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class,
1189                                                 void *info, ULONG len )
1190 {
1191     SYSCALL_FUNC( NtSetInformationJobObject );
1192 }
1193
1194 NTSTATUS SYSCALL_API NtSetInformationKey( HANDLE key, int class, void *info, ULONG length )
1195 {
1196     SYSCALL_FUNC( NtSetInformationKey );
1197 }
1198
1199 NTSTATUS SYSCALL_API NtSetInformationObject( HANDLE handle, OBJECT_INFORMATION_CLASS info_class,
1200                                              void *ptr, ULONG len )
1201 {
1202     SYSCALL_FUNC( NtSetInformationObject );
1203 }
1204
1205 NTSTATUS SYSCALL_API NtSetInformationProcess( HANDLE handle, PROCESSINFOCLASS class,
1206                                               void *info, ULONG size )
1207 {
1208     SYSCALL_FUNC( NtSetInformationProcess );
1209 }
1210
1211 NTSTATUS SYSCALL_API NtSetInformationThread( HANDLE handle, THREADINFOCLASS class,
1212                                              const void *data, ULONG length )
1213 {
1214     SYSCALL_FUNC( NtSetInformationThread );
1215 }
1216
1217 NTSTATUS SYSCALL_API NtSetInformationToken( HANDLE token, TOKEN_INFORMATION_CLASS class,
1218                                             void *info, ULONG length )
1219 {
1220     SYSCALL_FUNC( NtSetInformationToken );
1221 }
1222
1223 NTSTATUS SYSCALL_API NtSetInformationVirtualMemory( HANDLE process,
1224                                                     VIRTUAL_MEMORY_INFORMATION_CLASS info_class,
1225                                                     ULONG_PTR count, PMEMORY_RANGE_ENTRY addresses,
1226                                                     PVOID ptr, ULONG size )
1227 {
1228     SYSCALL_FUNC( NtSetInformationVirtualMemory );
1229 }
1230
1231 NTSTATUS SYSCALL_API NtSetIntervalProfile( ULONG interval, KPROFILE_SOURCE source )
1232 {
1233     SYSCALL_FUNC( NtSetIntervalProfile );
1234 }
1235
1236 NTSTATUS SYSCALL_API NtSetIoCompletion( HANDLE handle, ULONG_PTR key, ULONG_PTR value,
1237                                         NTSTATUS status, SIZE_T count )
1238 {
1239     SYSCALL_FUNC( NtSetIoCompletion );
1240 }
1241
1242 NTSTATUS SYSCALL_API NtSetLdtEntries( ULONG sel1, LDT_ENTRY entry1, ULONG sel2, LDT_ENTRY entry2 )
1243 {
1244     SYSCALL_FUNC( NtSetLdtEntries );
1245 }
1246
1247 NTSTATUS SYSCALL_API NtSetSecurityObject( HANDLE handle, SECURITY_INFORMATION info,
1248                                           PSECURITY_DESCRIPTOR descr )
1249 {
1250     SYSCALL_FUNC( NtSetSecurityObject );
1251 }
1252
1253 NTSTATUS SYSCALL_API NtSetSystemInformation( SYSTEM_INFORMATION_CLASS class, void *info, ULONG length )
1254 {
1255     SYSCALL_FUNC( NtSetSystemInformation );
1256 }
1257
1258 NTSTATUS SYSCALL_API NtSetSystemTime( const LARGE_INTEGER *new, LARGE_INTEGER *old )
1259 {
1260     SYSCALL_FUNC( NtSetSystemTime );
1261 }
1262
1263 NTSTATUS SYSCALL_API NtSetThreadExecutionState( EXECUTION_STATE new_state, EXECUTION_STATE *old_state )
1264 {
1265     SYSCALL_FUNC( NtSetThreadExecutionState );
1266 }
1267
1268 NTSTATUS SYSCALL_API NtSetTimer( HANDLE handle, const LARGE_INTEGER *when, PTIMER_APC_ROUTINE callback,
1269                                  void *arg, BOOLEAN resume, ULONG period, BOOLEAN *state )
1270 {
1271     SYSCALL_FUNC( NtSetTimer );
1272 }
1273
1274 NTSTATUS SYSCALL_API NtSetTimerResolution( ULONG res, BOOLEAN set, ULONG *current_res )
1275 {
1276     SYSCALL_FUNC( NtSetTimerResolution );
1277 }
1278
1279 NTSTATUS SYSCALL_API NtSetValueKey( HANDLE key, const UNICODE_STRING *name, ULONG index,
1280                                     ULONG type, const void *data, ULONG count )
1281 {
1282     SYSCALL_FUNC( NtSetValueKey );
1283 }
1284
1285 NTSTATUS SYSCALL_API NtSetVolumeInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, void *info,
1286                                                  ULONG length, FS_INFORMATION_CLASS class )
1287 {
1288     SYSCALL_FUNC( NtSetVolumeInformationFile );
1289 }
1290
1291 NTSTATUS SYSCALL_API NtShutdownSystem( SHUTDOWN_ACTION action )
1292 {
1293     SYSCALL_FUNC( NtShutdownSystem );
1294 }
1295
1296 NTSTATUS SYSCALL_API NtSignalAndWaitForSingleObject( HANDLE signal, HANDLE wait,
1297                                                      BOOLEAN alertable, const LARGE_INTEGER *timeout )
1298 {
1299     SYSCALL_FUNC( NtSignalAndWaitForSingleObject );
1300 }
1301
1302 NTSTATUS SYSCALL_API NtSuspendProcess( HANDLE handle )
1303 {
1304     SYSCALL_FUNC( NtSuspendProcess );
1305 }
1306
1307 NTSTATUS SYSCALL_API NtSuspendThread( HANDLE handle, ULONG *count )
1308 {
1309     SYSCALL_FUNC( NtSuspendThread );
1310 }
1311
1312 NTSTATUS SYSCALL_API NtSystemDebugControl( SYSDBG_COMMAND command, void *in_buff, ULONG in_len,
1313                                            void *out_buff, ULONG out_len, ULONG *retlen )
1314 {
1315     SYSCALL_FUNC( NtSystemDebugControl );
1316 }
1317
1318 NTSTATUS SYSCALL_API NtTerminateJobObject( HANDLE handle, NTSTATUS status )
1319 {
1320     SYSCALL_FUNC( NtTerminateJobObject );
1321 }
1322
1323 NTSTATUS SYSCALL_API NtTerminateProcess( HANDLE handle, LONG exit_code )
1324 {
1325     SYSCALL_FUNC( NtTerminateProcess );
1326 }
1327
1328 NTSTATUS SYSCALL_API NtTerminateThread( HANDLE handle, LONG exit_code )
1329 {
1330     SYSCALL_FUNC( NtTerminateThread );
1331 }
1332
1333 NTSTATUS SYSCALL_API NtTestAlert(void)
1334 {
1335     SYSCALL_FUNC( NtTestAlert );
1336 }
1337
1338 NTSTATUS SYSCALL_API NtTraceControl( ULONG code, void *inbuf, ULONG inbuf_len,
1339                                      void *outbuf, ULONG outbuf_len, ULONG *size )
1340 {
1341     SYSCALL_FUNC( NtTraceControl );
1342 }
1343
1344 NTSTATUS SYSCALL_API NtUnloadDriver( const UNICODE_STRING *name )
1345 {
1346     SYSCALL_FUNC( NtUnloadDriver );
1347 }
1348
1349 NTSTATUS SYSCALL_API NtUnloadKey( OBJECT_ATTRIBUTES *attr )
1350 {
1351     SYSCALL_FUNC( NtUnloadKey );
1352 }
1353
1354 NTSTATUS SYSCALL_API NtUnlockFile( HANDLE handle, IO_STATUS_BLOCK *io_status, LARGE_INTEGER *offset,
1355                                    LARGE_INTEGER *count, ULONG *key )
1356 {
1357     SYSCALL_FUNC( NtUnlockFile );
1358 }
1359
1360 NTSTATUS SYSCALL_API NtUnlockVirtualMemory( HANDLE process, PVOID *addr, SIZE_T *size, ULONG unknown )
1361 {
1362     SYSCALL_FUNC( NtUnlockVirtualMemory );
1363 }
1364
1365 NTSTATUS SYSCALL_API NtUnmapViewOfSection( HANDLE process, PVOID addr )
1366 {
1367     SYSCALL_FUNC( NtUnmapViewOfSection );
1368 }
1369
1370 NTSTATUS SYSCALL_API NtUnmapViewOfSectionEx( HANDLE process, PVOID addr, ULONG flags )
1371 {
1372     SYSCALL_FUNC( NtUnmapViewOfSectionEx );
1373 }
1374
1375 NTSTATUS SYSCALL_API NtWaitForAlertByThreadId( const void *address, const LARGE_INTEGER *timeout )
1376 {
1377     SYSCALL_FUNC( NtWaitForAlertByThreadId );
1378 }
1379
1380 NTSTATUS SYSCALL_API NtWaitForDebugEvent( HANDLE handle, BOOLEAN alertable, LARGE_INTEGER *timeout,
1381                                           DBGUI_WAIT_STATE_CHANGE *state )
1382 {
1383     SYSCALL_FUNC( NtWaitForDebugEvent );
1384 }
1385
1386 NTSTATUS SYSCALL_API NtWaitForKeyedEvent( HANDLE handle, const void *key,
1387                                           BOOLEAN alertable, const LARGE_INTEGER *timeout )
1388 {
1389     SYSCALL_FUNC( NtWaitForKeyedEvent );
1390 }
1391
1392 NTSTATUS SYSCALL_API NtWaitForMultipleObjects( DWORD count, const HANDLE *handles, BOOLEAN wait_any,
1393                                                BOOLEAN alertable, const LARGE_INTEGER *timeout )
1394 {
1395     SYSCALL_FUNC( NtWaitForMultipleObjects );
1396 }
1397
1398 NTSTATUS SYSCALL_API NtWaitForSingleObject( HANDLE handle, BOOLEAN alertable, const LARGE_INTEGER *timeout )
1399 {
1400     SYSCALL_FUNC( NtWaitForSingleObject );
1401 }
1402
1403 NTSTATUS SYSCALL_API NtWriteFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
1404                                   IO_STATUS_BLOCK *io, const void *buffer, ULONG length,
1405                                   LARGE_INTEGER *offset, ULONG *key )
1406 {
1407     SYSCALL_FUNC( NtWriteFile );
1408 }
1409
1410 NTSTATUS SYSCALL_API NtWriteFileGather( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
1411                                         IO_STATUS_BLOCK *io, FILE_SEGMENT_ELEMENT *segments,
1412                                         ULONG length, LARGE_INTEGER *offset, ULONG *key )
1413 {
1414     SYSCALL_FUNC( NtWriteFileGather );
1415 }
1416
1417 NTSTATUS SYSCALL_API NtWriteVirtualMemory( HANDLE process, void *addr, const void *buffer,
1418                                            SIZE_T size, SIZE_T *bytes_written )
1419 {
1420     SYSCALL_FUNC( NtWriteVirtualMemory );
1421 }
1422
1423 NTSTATUS SYSCALL_API NtYieldExecution(void)
1424 {
1425     SYSCALL_FUNC( NtYieldExecution );
1426 }
1427
1428 NTSTATUS SYSCALL_API wine_nt_to_unix_file_name( const OBJECT_ATTRIBUTES *attr, char *nameA, ULONG *size,
1429                                                 UINT disposition )
1430 {
1431     SYSCALL_FUNC( wine_nt_to_unix_file_name );
1432 }
1433
1434 NTSTATUS SYSCALL_API wine_unix_to_nt_file_name( const char *name, WCHAR *buffer, ULONG *size )
1435 {
1436     SYSCALL_FUNC( wine_unix_to_nt_file_name );
1437 }
1438
1439 static void * const arm64ec_syscalls[] =
1440 {
1441 #define SYSCALL_ENTRY(id,name,args) name,
1442     ALL_SYSCALLS64
1443 #undef SYSCALL_ENTRY
1444 };
1445
1446
1447 /***********************************************************************
1448  *           LdrpGetX64Information
1449  */
1450 static NTSTATUS WINAPI LdrpGetX64Information( ULONG type, void *output, void *extra_info )
1451 {
1452     switch (type)
1453     {
1454     case 0:
1455     {
1456         UINT64 fpcr, fpsr;
1457
1458         __asm__ __volatile__( "mrs %0, fpcr; mrs %1, fpsr" : "=r" (fpcr), "=r" (fpsr) );
1459         *(UINT *)output = fpcsr_to_mxcsr( fpcr, fpsr );
1460         return STATUS_SUCCESS;
1461     }
1462     default:
1463         FIXME( "not implemented type %u\n", type );
1464         return STATUS_INVALID_PARAMETER;
1465     }
1466 }
1467
1468 /***********************************************************************
1469  *           LdrpSetX64Information
1470  */
1471 static NTSTATUS WINAPI LdrpSetX64Information( ULONG type, ULONG_PTR input, void *extra_info )
1472 {
1473     switch (type)
1474     {
1475     case 0:
1476     {
1477         UINT64 fpcsr = mxcsr_to_fpcsr( input );
1478         __asm__ __volatile__( "msr fpcr, %0; msr fpsr, %1" :: "r" (fpcsr), "r" (fpcsr >> 32) );
1479         return STATUS_SUCCESS;
1480     }
1481     default:
1482         FIXME( "not implemented type %u\n", type );
1483         return STATUS_INVALID_PARAMETER;
1484     }
1485 }
1486
1487
1488 /*******************************************************************
1489  *              KiUserExceptionDispatcher (NTDLL.@)
1490  */
1491 NTSTATUS WINAPI KiUserExceptionDispatcher( EXCEPTION_RECORD *rec, CONTEXT *context )
1492 {
1493     FIXME( "not implemented\n" );
1494     return STATUS_INVALID_DISPOSITION;
1495 }
1496
1497
1498 /*******************************************************************
1499  *              KiUserApcDispatcher (NTDLL.@)
1500  */
1501 void WINAPI dispatch_apc( void (CALLBACK *func)(ULONG_PTR,ULONG_PTR,ULONG_PTR,CONTEXT*),
1502                           ULONG_PTR arg1, ULONG_PTR arg2, ULONG_PTR arg3,
1503                           BOOLEAN alertable, ARM64_NT_CONTEXT *arm_ctx )
1504 {
1505     ARM64EC_NT_CONTEXT context;
1506
1507     context_arm_to_x64( &context, arm_ctx );
1508     func( arg1, arg2, arg3, &context.AMD64_Context );
1509     NtContinue( &context.AMD64_Context, alertable );
1510 }
1511 __ASM_GLOBAL_FUNC( "#KiUserApcDispatcher",
1512                    __ASM_SEH(".seh_context\n\t")
1513                    "nop\n\t"
1514                    __ASM_SEH(".seh_stackalloc 0x30\n\t")
1515                    __ASM_SEH(".seh_endprologue\n\t")
1516                    "ldp x0, x1, [sp]\n\t"         /* func, arg1 */
1517                    "ldp x2, x3, [sp, #0x10]\n\t"  /* arg2, arg3 */
1518                    "ldr w4, [sp, #0x20]\n\t"      /* alertable */
1519                    "add x5, sp, #0x30\n\t"        /* context */
1520                    "bl " __ASM_NAME("dispatch_apc") "\n\t"
1521                    "brk #1" )
1522
1523
1524 /*******************************************************************
1525  *              KiUserCallbackDispatcher (NTDLL.@)
1526  */
1527 __ASM_GLOBAL_FUNC( "#KiUserCallbackDispatcher",
1528                    ".seh_pushframe\n\t"
1529                    "nop\n\t"
1530                    ".seh_stackalloc 0x20\n\t"
1531                    "nop\n\t"
1532                    ".seh_save_reg lr, 0x18\n\t"
1533                    ".seh_endprologue\n\t"
1534                    ".seh_handler " __ASM_NAME("user_callback_handler") ", @except\n\t"
1535                    "ldr x0, [sp]\n\t"             /* args */
1536                    "ldp w1, w2, [sp, #0x08]\n\t"  /* len, id */
1537                    "ldr x3, [x18, 0x60]\n\t"      /* peb */
1538                    "ldr x3, [x3, 0x58]\n\t"       /* peb->KernelCallbackTable */
1539                    "ldr x15, [x3, x2, lsl #3]\n\t"
1540                    "blr x15\n\t"
1541                    ".globl \"#KiUserCallbackDispatcherReturn\"\n"
1542                    "\"#KiUserCallbackDispatcherReturn\":\n\t"
1543                    "mov x2, x0\n\t"               /* status */
1544                    "mov x1, #0\n\t"               /* ret_len */
1545                    "mov x0, x1\n\t"               /* ret_ptr */
1546                    "bl " __ASM_NAME("NtCallbackReturn") "\n\t"
1547                    "bl " __ASM_NAME("RtlRaiseStatus") "\n\t"
1548                    "brk #1" )
1549
1550
1551 /**************************************************************************
1552  *              RtlIsEcCode (NTDLL.@)
1553  */
1554 BOOLEAN WINAPI RtlIsEcCode( const void *ptr )
1555 {
1556     const UINT64 *map = (const UINT64 *)NtCurrentTeb()->Peb->EcCodeBitMap;
1557     ULONG_PTR page = (ULONG_PTR)ptr / page_size;
1558     return (map[page / 64] >> (page & 63)) & 1;
1559 }
1560
1561
1562 /***********************************************************************
1563  *              RtlCaptureContext (NTDLL.@)
1564  */
1565 void WINAPI RtlCaptureContext( CONTEXT *context )
1566 {
1567     FIXME( "not implemented\n" );
1568 }
1569
1570
1571 /*******************************************************************
1572  *              RtlRestoreContext (NTDLL.@)
1573  */
1574 void CDECL RtlRestoreContext( CONTEXT *context, EXCEPTION_RECORD *rec )
1575 {
1576     FIXME( "not implemented\n" );
1577 }
1578
1579
1580 /*******************************************************************
1581  *              RtlUnwindEx (NTDLL.@)
1582  */
1583 void WINAPI RtlUnwindEx( PVOID end_frame, PVOID target_ip, EXCEPTION_RECORD *rec,
1584                          PVOID retval, CONTEXT *context, UNWIND_HISTORY_TABLE *table )
1585 {
1586     FIXME( "not implemented\n" );
1587 }
1588
1589
1590 /*******************************************************************
1591  *              __C_specific_handler (NTDLL.@)
1592  */
1593 EXCEPTION_DISPOSITION WINAPI __C_specific_handler( EXCEPTION_RECORD *rec,
1594                                                    void *frame,
1595                                                    CONTEXT *context,
1596                                                    struct _DISPATCHER_CONTEXT *dispatch )
1597 {
1598     FIXME( "not implemented\n" );
1599     return ExceptionContinueSearch;
1600 }
1601
1602
1603 /*************************************************************************
1604  *              RtlCaptureStackBackTrace (NTDLL.@)
1605  */
1606 USHORT WINAPI RtlCaptureStackBackTrace( ULONG skip, ULONG count, PVOID *buffer, ULONG *hash )
1607 {
1608     FIXME( "not implemented\n" );
1609     return 0;
1610 }
1611
1612
1613 static int code_match( BYTE *code, const BYTE *seq, size_t len )
1614 {
1615     for ( ; len; len--, code++, seq++) if (*seq && *code != *seq) return 0;
1616     return 1;
1617 }
1618
1619 void *check_call( void **target, void *exit_thunk, void *dest )
1620 {
1621     static const BYTE jmp_sequence[] =
1622     {
1623         0xff, 0x25              /* jmp *xxx(%rip) */
1624     };
1625     static const BYTE fast_forward_sequence[] =
1626     {
1627         0x48, 0x8b, 0xc4,       /* mov  %rsp,%rax */
1628         0x48, 0x89, 0x58, 0x20, /* mov  %rbx,0x20(%rax) */
1629         0x55,                   /* push %rbp */
1630         0x5d,                   /* pop  %rbp */
1631         0xe9                    /* jmp  arm_code */
1632     };
1633     static const BYTE syscall_sequence[] =
1634     {
1635         0x4c, 0x8b, 0xd1,       /* mov  %rcx,%r10 */
1636         0xb8, 0, 0, 0, 0,       /* mov  $xxx,%eax */
1637         0xf6, 0x04, 0x25, 0x08, /* testb $0x1,0x7ffe0308 */
1638         0x03, 0xfe, 0x7f, 0x01,
1639         0x75, 0x03,             /* jne 1f */
1640         0x0f, 0x05,             /* syscall */
1641         0xc3,                   /* ret */
1642         0xcd, 0x2e,             /* 1: int $0x2e */
1643         0xc3                    /* ret */
1644     };
1645
1646     for (;;)
1647     {
1648         if (dest == __wine_unix_call_dispatcher) return dest;
1649         if (RtlIsEcCode( dest )) return dest;
1650         if (code_match( dest, jmp_sequence, sizeof(jmp_sequence) ))
1651         {
1652             int *off_ptr = (int *)((char *)dest + sizeof(jmp_sequence));
1653             void **addr_ptr = (void **)((char *)(off_ptr + 1) + *off_ptr);
1654             dest = *addr_ptr;
1655             continue;
1656         }
1657         if (!((ULONG_PTR)dest & 15))  /* fast-forward and syscall thunks are always aligned */
1658         {
1659             if (code_match( dest, fast_forward_sequence, sizeof(fast_forward_sequence) ))
1660             {
1661                 int *off_ptr = (int *)((char *)dest + sizeof(fast_forward_sequence));
1662                 return (char *)(off_ptr + 1) + *off_ptr;
1663             }
1664             if (code_match( dest, syscall_sequence, sizeof(syscall_sequence) ))
1665             {
1666                 ULONG id = ((ULONG *)dest)[1];
1667                 if (id < ARRAY_SIZE(arm64ec_syscalls)) return arm64ec_syscalls[id];
1668             }
1669         }
1670         *target = dest;
1671         return exit_thunk;
1672     }
1673 }
1674
1675 static void __attribute__((naked)) arm64x_check_call(void)
1676 {
1677     asm( "stp x29, x30, [sp,#-0xb0]!\n\t"
1678          "mov x29, sp\n\t"
1679          "stp x0, x1,   [sp, #0x10]\n\t"
1680          "stp x2, x3,   [sp, #0x20]\n\t"
1681          "stp x4, x5,   [sp, #0x30]\n\t"
1682          "stp x6, x7,   [sp, #0x40]\n\t"
1683          "stp x8, x9,   [sp, #0x50]\n\t"
1684          "stp x10, x15, [sp, #0x60]\n\t"
1685          "stp d0, d1,   [sp, #0x70]\n\t"
1686          "stp d2, d3,   [sp, #0x80]\n\t"
1687          "stp d4, d5,   [sp, #0x90]\n\t"
1688          "stp d6, d7,   [sp, #0xa0]\n\t"
1689          "add x0, sp, #0x58\n\t"  /* x9 = &target */
1690          "mov x1, x10\n\t"        /* x10 = exit_thunk */
1691          "mov x2, x11\n\t"        /* x11 = dest */
1692          "bl " __ASM_NAME("check_call") "\n\t"
1693          "mov x11, x0\n\t"
1694          "ldp x0, x1,   [sp, #0x10]\n\t"
1695          "ldp x2, x3,   [sp, #0x20]\n\t"
1696          "ldp x4, x5,   [sp, #0x30]\n\t"
1697          "ldp x6, x7,   [sp, #0x40]\n\t"
1698          "ldp x8, x9,   [sp, #0x50]\n\t"
1699          "ldp x10, x15, [sp, #0x60]\n\t"
1700          "ldp d0, d1,   [sp, #0x70]\n\t"
1701          "ldp d2, d3,   [sp, #0x80]\n\t"
1702          "ldp d4, d5,   [sp, #0x90]\n\t"
1703          "ldp d6, d7,   [sp, #0xa0]\n\t"
1704          "ldp x29, x30, [sp], #0xb0\n\t"
1705          "ret" );
1706 }
1707
1708
1709 /**************************************************************************
1710  *              __chkstk (NTDLL.@)
1711  *
1712  * Supposed to touch all the stack pages, but we shouldn't need that.
1713  */
1714 void __attribute__((naked)) __chkstk(void)
1715 {
1716     asm( "ret" );
1717 }
1718
1719
1720 /**************************************************************************
1721  *              __chkstk_arm64ec (NTDLL.@)
1722  *
1723  * Supposed to touch all the stack pages, but we shouldn't need that.
1724  */
1725 void __attribute__((naked)) __chkstk_arm64ec(void)
1726 {
1727     asm( "ret" );
1728 }
1729
1730
1731 /***********************************************************************
1732  *              RtlRaiseException (NTDLL.@)
1733  */
1734 void WINAPI RtlRaiseException( struct _EXCEPTION_RECORD * rec)
1735 {
1736     FIXME( "not implemented\n" );
1737 }
1738
1739
1740 /***********************************************************************
1741  *           RtlUserThreadStart (NTDLL.@)
1742  */
1743 void WINAPI RtlUserThreadStart( PRTL_THREAD_START_ROUTINE entry, void *arg )
1744 {
1745     __TRY
1746     {
1747         pBaseThreadInitThunk( 0, (LPTHREAD_START_ROUTINE)entry, arg );
1748     }
1749     __EXCEPT(call_unhandled_exception_filter)
1750     {
1751         NtTerminateProcess( GetCurrentProcess(), GetExceptionCode() );
1752     }
1753     __ENDTRY
1754 }
1755
1756
1757 /******************************************************************
1758  *              LdrInitializeThunk (NTDLL.@)
1759  */
1760 void WINAPI LdrInitializeThunk( CONTEXT *arm_context, ULONG_PTR unk2, ULONG_PTR unk3, ULONG_PTR unk4 )
1761 {
1762     ARM64EC_NT_CONTEXT context;
1763
1764     if (!__os_arm64x_check_call)
1765     {
1766         __os_arm64x_check_call = arm64x_check_call;
1767         __os_arm64x_check_icall = arm64x_check_call;
1768         __os_arm64x_check_icall_cfg = arm64x_check_call;
1769         __os_arm64x_get_x64_information = LdrpGetX64Information;
1770         __os_arm64x_set_x64_information = LdrpSetX64Information;
1771     }
1772
1773     context_arm_to_x64( &context, (ARM64_NT_CONTEXT *)arm_context );
1774     loader_init( &context.AMD64_Context, (void **)&context.X0 );
1775     TRACE_(relay)( "\1Starting thread proc %p (arg=%p)\n", (void *)context.X0, (void *)context.X1 );
1776     NtContinue( &context.AMD64_Context, TRUE );
1777 }
1778
1779
1780 /***********************************************************************
1781  *           process_breakpoint
1782  */
1783 __ASM_GLOBAL_FUNC( "#process_breakpoint",
1784                    ".seh_endprologue\n\t"
1785                    ".seh_handler process_breakpoint_handler, @except\n\t"
1786                    "brk #0xf000\n\t"
1787                    "ret\n"
1788                    "process_breakpoint_handler:\n\t"
1789                    "ldr x4, [x2, #0x108]\n\t" /* context->Pc */
1790                    "add x4, x4, #4\n\t"
1791                    "str x4, [x2, #0x108]\n\t"
1792                    "mov w0, #0\n\t"           /* ExceptionContinueExecution */
1793                    "ret" )
1794
1795 /***********************************************************************
1796  *              DbgUiRemoteBreakin   (NTDLL.@)
1797  */
1798 void WINAPI DbgUiRemoteBreakin( void *arg )
1799 {
1800     if (NtCurrentTeb()->Peb->BeingDebugged)
1801     {
1802         __TRY
1803         {
1804             DbgBreakPoint();
1805         }
1806         __EXCEPT_ALL
1807         {
1808             /* do nothing */
1809         }
1810         __ENDTRY
1811     }
1812     RtlExitUserThread( STATUS_SUCCESS );
1813 }
1814
1815 /**********************************************************************
1816  *              DbgBreakPoint   (NTDLL.@)
1817  */
1818 void __attribute__((naked)) DbgBreakPoint(void)
1819 {
1820     asm( ".seh_proc DbgBreakPoint\n\t"
1821          ".seh_endprologue\n\t"
1822          "brk #0xf000\n\t"
1823          "ret\n\t"
1824          ".seh_endproc" );
1825 }
1826
1827
1828 /**********************************************************************
1829  *              DbgUserBreakPoint   (NTDLL.@)
1830  */
1831 void __attribute__((naked)) DbgUserBreakPoint(void)
1832 {
1833     asm( ".seh_proc DbgUserBreakPoint\n\t"
1834          ".seh_endprologue\n\t"
1835          "brk #0xf000\n\t"
1836          "ret\n\t"
1837          ".seh_endproc" );
1838 }
1839
1840 #endif  /* __arm64ec__ */