Ros-diffs

ros-diffs@reactos.org

81390 discussions

[reactos] 01/01: [DISKPART] Add help text for the SELECT DISK command
by Eric Kohl 11 Jun '22

11 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f06066dc6e893d78a6c6b… commit f06066dc6e893d78a6c6bf3d4cc9224c4062edc0 Author: Eric Kohl <eric.kohl(a)reactos.org> AuthorDate: Sat Jun 11 13:13:27 2022 +0200 Commit: Eric Kohl <eric.kohl(a)reactos.org> CommitDate: Sat Jun 11 13:13:27 2022 +0200 [DISKPART] Add help text for the SELECT DISK command --- base/system/diskpart/diskpart_msg.mc | 405 ++++++++++++++++++++++++++++++++++- 1 file changed, 395 insertions(+), 10 deletions(-) diff --git a/base/system/diskpart/diskpart_msg.mc b/base/system/diskpart/diskpart_msg.mc index c974c6ddc72..ed0cebc248e 100644 --- a/base/system/diskpart/diskpart_msg.mc +++ b/base/system/diskpart/diskpart_msg.mc @@ -2778,34 +2778,419 @@ SymbolicName=MSG_COMMAND_SELECT_DISK Severity=Informational Facility=System Language=English -<Add SELECT DISK command help text here> + Selects the specified disk and shifts the focus to it. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + The DiskPart disk index number of the disk to receive + focus. + + DISK=<Path> + The location path of the disk to receive focus. + + DISK=SYSTEM + On BIOS machines, BIOS disk 0 will receive focus. + On EFI machines, the disk containing the ESP partition + used for the current boot will receive focus. On EFI + machines, if there is no ESP, or there is more than + one ESP present, or the machine is booted from Windows PE, + the command will fail. + + DISK=NEXT + Once a disk is selected, this command is used to iterate + over all disks in the disk list. The next disk in the list + will receive focus. If the next disk is the start of the + enumeration, the command will fail and no disk will have + focus. + + If no options are specified, the select command lists the disk that + currently has the focus. You can view the DiskPart index numbers + for all disks on the computer by using the LIST DISK command. + +Example: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) . Language=German -<Add SELECT DISK command help text here> + Dient zum Auswählen des angegebenen Datenträgers sowie zum + Festlegen des Fokus auf den Datenträger. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + Die DiskPart-Datenträgerindexnummer des Datenträgers, auf + den der Fokus festgelegt werden soll. + + DISK=<Pfad> + Der Speicherortpfad des Datenträgers, auf den der Fokus + festgelegt werden soll. + + DISK=SYSTEM + Bei BIOS-Computern erhält der BIOS-Datenträger "0" den + Fokus. Bei EFI-Computern erhält der Datenträger mit der + ESP-Partition, der für den aktuellen Startvorgang verwendet + wird, den Fokus. Bei EFI-Computern ohne ESP oder mit + mehreren ESPs (oder beim Start des Computers unter Ver- + wendung von Windows PE) tritt bei Verwendung des Befehls + ein Fehler auf. + + DISK=NEXT + Nach Auswahl eines Datenträgers erfolgt mithilfe dieses + Befehls eine Iteration durch alle Datenträger in der Daten- + trägerliste. Der nächste Datenträger in der Liste erhält den + Fokus. Handelt es sich beim nächsten Datenträger um den + Beginn der Aufzählung, tritt bei dem Befehl ein Fehler auf, und + keiner der Datenträger erhält den Fokus. + + Ohne Angabe von Optionen wird mithilfe des Befehls "Select" der + Datenträger angegeben, der derzeit den Fokus besitzt. Verwenden + Sie zum Anzeigen der DiskPart-Indexnummern für alle Datenträger + des Computers den Befehl "LIST DISK". + +Beispiele: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) . Language=Polish -<Add SELECT DISK command help text here> + Selects the specified disk and shifts the focus to it. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + The DiskPart disk index number of the disk to receive + focus. + + DISK=<Path> + The location path of the disk to receive focus. + + DISK=SYSTEM + On BIOS machines, BIOS disk 0 will receive focus. + On EFI machines, the disk containing the ESP partition + used for the current boot will receive focus. On EFI + machines, if there is no ESP, or there is more than + one ESP present, or the machine is booted from Windows PE, + the command will fail. + + DISK=NEXT + Once a disk is selected, this command is used to iterate + over all disks in the disk list. The next disk in the list + will receive focus. If the next disk is the start of the + enumeration, the command will fail and no disk will have + focus. + + If no options are specified, the select command lists the disk that + currently has the focus. You can view the DiskPart index numbers + for all disks on the computer by using the LIST DISK command. + +Example: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) . Language=Portugese -<Add SELECT DISK command help text here> + Selects the specified disk and shifts the focus to it. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + The DiskPart disk index number of the disk to receive + focus. + + DISK=<Path> + The location path of the disk to receive focus. + + DISK=SYSTEM + On BIOS machines, BIOS disk 0 will receive focus. + On EFI machines, the disk containing the ESP partition + used for the current boot will receive focus. On EFI + machines, if there is no ESP, or there is more than + one ESP present, or the machine is booted from Windows PE, + the command will fail. + + DISK=NEXT + Once a disk is selected, this command is used to iterate + over all disks in the disk list. The next disk in the list + will receive focus. If the next disk is the start of the + enumeration, the command will fail and no disk will have + focus. + + If no options are specified, the select command lists the disk that + currently has the focus. You can view the DiskPart index numbers + for all disks on the computer by using the LIST DISK command. + +Example: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) . Language=Romanian -<Add SELECT DISK command help text here> + Selects the specified disk and shifts the focus to it. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + The DiskPart disk index number of the disk to receive + focus. + + DISK=<Path> + The location path of the disk to receive focus. + + DISK=SYSTEM + On BIOS machines, BIOS disk 0 will receive focus. + On EFI machines, the disk containing the ESP partition + used for the current boot will receive focus. On EFI + machines, if there is no ESP, or there is more than + one ESP present, or the machine is booted from Windows PE, + the command will fail. + + DISK=NEXT + Once a disk is selected, this command is used to iterate + over all disks in the disk list. The next disk in the list + will receive focus. If the next disk is the start of the + enumeration, the command will fail and no disk will have + focus. + + If no options are specified, the select command lists the disk that + currently has the focus. You can view the DiskPart index numbers + for all disks on the computer by using the LIST DISK command. + +Example: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) . Language=Russian -<Add SELECT DISK command help text here> + Selects the specified disk and shifts the focus to it. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + The DiskPart disk index number of the disk to receive + focus. + + DISK=<Path> + The location path of the disk to receive focus. + + DISK=SYSTEM + On BIOS machines, BIOS disk 0 will receive focus. + On EFI machines, the disk containing the ESP partition + used for the current boot will receive focus. On EFI + machines, if there is no ESP, or there is more than + one ESP present, or the machine is booted from Windows PE, + the command will fail. + + DISK=NEXT + Once a disk is selected, this command is used to iterate + over all disks in the disk list. The next disk in the list + will receive focus. If the next disk is the start of the + enumeration, the command will fail and no disk will have + focus. + + If no options are specified, the select command lists the disk that + currently has the focus. You can view the DiskPart index numbers + for all disks on the computer by using the LIST DISK command. + +Example: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) . Language=Albanian -<Add SELECT DISK command help text here> + Selects the specified disk and shifts the focus to it. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + The DiskPart disk index number of the disk to receive + focus. + + DISK=<Path> + The location path of the disk to receive focus. + + DISK=SYSTEM + On BIOS machines, BIOS disk 0 will receive focus. + On EFI machines, the disk containing the ESP partition + used for the current boot will receive focus. On EFI + machines, if there is no ESP, or there is more than + one ESP present, or the machine is booted from Windows PE, + the command will fail. + + DISK=NEXT + Once a disk is selected, this command is used to iterate + over all disks in the disk list. The next disk in the list + will receive focus. If the next disk is the start of the + enumeration, the command will fail and no disk will have + focus. + + If no options are specified, the select command lists the disk that + currently has the focus. You can view the DiskPart index numbers + for all disks on the computer by using the LIST DISK command. + +Example: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) . Language=Turkish -<Add SELECT DISK command help text here> + Selects the specified disk and shifts the focus to it. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + The DiskPart disk index number of the disk to receive + focus. + + DISK=<Path> + The location path of the disk to receive focus. + + DISK=SYSTEM + On BIOS machines, BIOS disk 0 will receive focus. + On EFI machines, the disk containing the ESP partition + used for the current boot will receive focus. On EFI + machines, if there is no ESP, or there is more than + one ESP present, or the machine is booted from Windows PE, + the command will fail. + + DISK=NEXT + Once a disk is selected, this command is used to iterate + over all disks in the disk list. The next disk in the list + will receive focus. If the next disk is the start of the + enumeration, the command will fail and no disk will have + focus. + + If no options are specified, the select command lists the disk that + currently has the focus. You can view the DiskPart index numbers + for all disks on the computer by using the LIST DISK command. + +Example: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) . Language=Chinese -<Add SELECT DISK command help text here> + Selects the specified disk and shifts the focus to it. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + The DiskPart disk index number of the disk to receive + focus. + + DISK=<Path> + The location path of the disk to receive focus. + + DISK=SYSTEM + On BIOS machines, BIOS disk 0 will receive focus. + On EFI machines, the disk containing the ESP partition + used for the current boot will receive focus. On EFI + machines, if there is no ESP, or there is more than + one ESP present, or the machine is booted from Windows PE, + the command will fail. + + DISK=NEXT + Once a disk is selected, this command is used to iterate + over all disks in the disk list. The next disk in the list + will receive focus. If the next disk is the start of the + enumeration, the command will fail and no disk will have + focus. + + If no options are specified, the select command lists the disk that + currently has the focus. You can view the DiskPart index numbers + for all disks on the computer by using the LIST DISK command. + +Example: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) . Language=Taiwanese -<Add SELECT DISK command help text here> + Selects the specified disk and shifts the focus to it. + +Syntax: SELECT DISK=<N> + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=<Path> + + DISK=<N> + The DiskPart disk index number of the disk to receive + focus. + + DISK=<Path> + The location path of the disk to receive focus. + + DISK=SYSTEM + On BIOS machines, BIOS disk 0 will receive focus. + On EFI machines, the disk containing the ESP partition + used for the current boot will receive focus. On EFI + machines, if there is no ESP, or there is more than + one ESP present, or the machine is booted from Windows PE, + the command will fail. + + DISK=NEXT + Once a disk is selected, this command is used to iterate + over all disks in the disk list. The next disk in the list + will receive focus. If the next disk is the start of the + enumeration, the command will fail and no disk will have + focus. + + If no options are specified, the select command lists the disk that + currently has the focus. You can view the DiskPart index numbers + for all disks on the computer by using the LIST DISK command. + +Example: + + SELECT DISK=1 + SELECT DISK=SYSTEM + SELECT DISK=NEXT + SELECT DISK=PCIROOT(0)#PCI(0100)#ATA(C00T00L01) .

1 0

[reactos] 03/03: [CRT] Implement xmmintrin.h
by Timo Kreuzer 10 Jun '22

10 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=318d696f0e2ba61fa4662… commit 318d696f0e2ba61fa4662029fdf400180e98a804 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Sat Jun 4 11:14:42 2022 +0200 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Fri Jun 10 23:21:41 2022 +0200 [CRT] Implement xmmintrin.h This includes inline functions for GCC/Clang. Note: the previous GCC definition of __m128 was broken and didn't work. --- sdk/include/crt/mingw32/intrin_x86.h | 9 - sdk/include/crt/xmmintrin.h | 1243 ++++++++++++++++++++++++++++++++-- 2 files changed, 1179 insertions(+), 73 deletions(-) diff --git a/sdk/include/crt/mingw32/intrin_x86.h b/sdk/include/crt/mingw32/intrin_x86.h index 888bf795313..1bfae865d77 100644 --- a/sdk/include/crt/mingw32/intrin_x86.h +++ b/sdk/include/crt/mingw32/intrin_x86.h @@ -111,15 +111,6 @@ __INTRIN_INLINE void _mm_lfence(void) } #endif -#if !HAS_BUILTIN(_mm_sfence) -__INTRIN_INLINE void _mm_sfence(void) -{ - _WriteBarrier(); - __asm__ __volatile__("sfence"); - _WriteBarrier(); -} -#endif - #if defined(__x86_64__) && !HAS_BUILTIN(__faststorefence) __INTRIN_INLINE void __faststorefence(void) { diff --git a/sdk/include/crt/xmmintrin.h b/sdk/include/crt/xmmintrin.h index 61ed2c9dcf6..a539f09be3b 100644 --- a/sdk/include/crt/xmmintrin.h +++ b/sdk/include/crt/xmmintrin.h @@ -1,25 +1,42 @@ -/** - * This file has no copyright assigned and is placed in the Public Domain. - * This file is part of the w64 mingw-runtime package. - * No warranty is given; refer to the file DISCLAIMER within this package. +/* + * xmmintrin.h + * + * This file is part of the ReactOS CRT package. + * + * Contributors: + * Timo Kreuzer (timo.kreuzer(a)reactos.org) + * + * THIS SOFTWARE IS NOT COPYRIGHTED + * + * This source code is offered for use in the public domain. You may + * use, modify or distribute it freely. + * + * This code is distributed in the hope that it will be useful but + * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY + * DISCLAIMED. This includes but is not limited to warranties of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * */ #pragma once #ifndef _INCLUDED_MM2 #define _INCLUDED_MM2 -#include <crtdefs.h> #include <mmintrin.h> -#ifdef __clang__ +#if defined(_MM2_FUNCTIONALITY) && !defined(_MM_FUNCTIONALITY) +#define _MM_FUNCTIONALITY +#endif -typedef float __v4sf __attribute__((__vector_size__(16))); -typedef signed int __v4si __attribute__((__vector_size__(16))); -typedef unsigned int __v4su __attribute__((__vector_size__(16))); +#if !defined _VCRT_BUILD && !defined _INC_MALLOC +//#include <malloc.h> // FIXME: This breaks build +#endif -typedef float __m128 __attribute__((__vector_size__(16), __aligned__(16))); +#ifdef __cplusplus +extern "C" { +#endif -#else /* __clang__ */ +#if defined(_MSC_VER) && !defined(__clang__) typedef union _DECLSPEC_INTRIN_TYPE _CRT_ALIGN(16) __m128 { @@ -34,96 +51,1194 @@ typedef union _DECLSPEC_INTRIN_TYPE _CRT_ALIGN(16) __m128 unsigned __int32 m128_u32[4]; } __m128; -#endif /* __clang__ */ +#define __ATTRIBUTE_SSE__ +#else /* _MSC_VER */ -#ifdef __cplusplus -extern "C" { + typedef float __v4sf __attribute__((__vector_size__(16))); + typedef signed int __v4si __attribute__((__vector_size__(16))); + typedef unsigned int __v4su __attribute__((__vector_size__(16))); + typedef float __m128_u __attribute__((__vector_size__(16), __aligned__(1))); + + typedef float __m128 __attribute__((__vector_size__(16), __aligned__(16))); + +#ifdef __clang__ +#define __ATTRIBUTE_SSE__ __attribute__((__target__("sse"),__min_vector_width__(128))) +#else +#define __ATTRIBUTE_SSE__ __attribute__((__target__("sse"))) #endif +#define __INTRIN_INLINE_SSE __INTRIN_INLINE __ATTRIBUTE_SSE__ -extern __m128 _mm_load_ss(float const*); -extern int _mm_cvt_ss2si(__m128); -__m128 _mm_xor_ps(__m128 a, __m128 b); -__m128 _mm_div_ps(__m128 a, __m128 b); +#endif /* _MSC_VER */ + +#define _MM_ALIGN16 _VCRT_ALIGN(16) + +/* Constants for use with _mm_prefetch. */ +#define _MM_HINT_NTA 0 +#define _MM_HINT_T0 1 +#define _MM_HINT_T1 2 +#define _MM_HINT_T2 3 +#define _MM_HINT_ENTA 4 +#if 0 // Not supported yet +#define _MM_HINT_ET0 5 +#define _MM_HINT_ET1 6 +#define _MM_HINT_ET2 7 +#endif + +/* Create a selector for use with the SHUFPS instruction. */ +#define _MM_SHUFFLE(fp3, fp2, fp1, fp0) \ + (((fp3) << 6) | ((fp2) << 4) | ((fp1) << 2) | (fp0)) + +/* Bits in the MXCSR. */ +#define _MM_EXCEPT_MASK 0x003f +#define _MM_EXCEPT_INVALID 0x0001 +#define _MM_EXCEPT_DENORM 0x0002 +#define _MM_EXCEPT_DIV_ZERO 0x0004 +#define _MM_EXCEPT_OVERFLOW 0x0008 +#define _MM_EXCEPT_UNDERFLOW 0x0010 +#define _MM_EXCEPT_INEXACT 0x0020 -#ifdef _MSC_VER +#define _MM_MASK_MASK 0x1f80 +#define _MM_MASK_INVALID 0x0080 +#define _MM_MASK_DENORM 0x0100 +#define _MM_MASK_DIV_ZERO 0x0200 +#define _MM_MASK_OVERFLOW 0x0400 +#define _MM_MASK_UNDERFLOW 0x0800 +#define _MM_MASK_INEXACT 0x1000 + +#define _MM_ROUND_MASK 0x6000 +#define _MM_ROUND_NEAREST 0x0000 +#define _MM_ROUND_DOWN 0x2000 +#define _MM_ROUND_UP 0x4000 +#define _MM_ROUND_TOWARD_ZERO 0x6000 + +#define _MM_FLUSH_ZERO_MASK 0x8000 +#define _MM_FLUSH_ZERO_ON 0x8000 +#define _MM_FLUSH_ZERO_OFF 0x0000 + +#ifdef __ICL +void* __cdecl _mm_malloc(size_t Size, size_t Al); +void __cdecl _mm_free(void* P); +#endif + +void _mm_prefetch(_In_ char const* p, _In_ int i); +__m128 _mm_setzero_ps(void); +__m128 _mm_add_ss(__m128 a, __m128 b); +__m128 _mm_sub_ss(__m128 a, __m128 b); +__m128 _mm_mul_ss(__m128 a, __m128 b); +__m128 _mm_div_ss(__m128 a, __m128 b); +__m128 _mm_sqrt_ss(__m128 a); +__m128 _mm_rcp_ss(__m128 a); +__m128 _mm_rsqrt_ss(__m128 a); +__m128 _mm_min_ss(__m128 a, __m128 b); +__m128 _mm_max_ss(__m128 a, __m128 b); +__m128 _mm_add_ps(__m128 a, __m128 b); +__m128 _mm_sub_ps(__m128 a, __m128 b); +__m128 _mm_mul_ps(__m128 a, __m128 b); +__m128 _mm_div_ps(__m128 a, __m128 b); +__m128 _mm_sqrt_ps(__m128 a); +__m128 _mm_rcp_ps(__m128 a); +__m128 _mm_rsqrt_ps(__m128 a); +__m128 _mm_min_ps(__m128 a, __m128 b); +__m128 _mm_max_ps(__m128 a, __m128 b); +__m128 _mm_and_ps(__m128 a, __m128 b); +__m128 _mm_andnot_ps(__m128 a, __m128 b); +__m128 _mm_or_ps(__m128 a, __m128 b); +__m128 _mm_xor_ps(__m128 a, __m128 b); +__m128 _mm_cmpeq_ss(__m128 a, __m128 b); +__m128 _mm_cmplt_ss(__m128 a, __m128 b); +__m128 _mm_cmple_ss(__m128 a, __m128 b); +__m128 _mm_cmpgt_ss(__m128 a, __m128 b); +__m128 _mm_cmpge_ss(__m128 a, __m128 b); +__m128 _mm_cmpneq_ss(__m128 a, __m128 b); +__m128 _mm_cmpnlt_ss(__m128 a, __m128 b); +__m128 _mm_cmpnle_ss(__m128 a, __m128 b); +__m128 _mm_cmpngt_ss(__m128 a, __m128 b); +__m128 _mm_cmpnge_ss(__m128 a, __m128 b); +__m128 _mm_cmpord_ss(__m128 a, __m128 b); +__m128 _mm_cmpunord_ss(__m128 a, __m128 b); +__m128 _mm_cmpeq_ps(__m128 a, __m128 b); +__m128 _mm_cmplt_ps(__m128 a, __m128 b); +__m128 _mm_cmple_ps(__m128 a, __m128 b); +__m128 _mm_cmpgt_ps(__m128 a, __m128 b); +__m128 _mm_cmpge_ps(__m128 a, __m128 b); +__m128 _mm_cmpneq_ps(__m128 a, __m128 b); +__m128 _mm_cmpnlt_ps(__m128 a, __m128 b); +__m128 _mm_cmpnle_ps(__m128 a, __m128 b); +__m128 _mm_cmpngt_ps(__m128 a, __m128 b); +__m128 _mm_cmpnge_ps(__m128 a, __m128 b); +__m128 _mm_cmpord_ps(__m128 a, __m128 b); +__m128 _mm_cmpunord_ps(__m128 a, __m128 b); +int _mm_comieq_ss(__m128 a, __m128 b); +int _mm_comilt_ss(__m128 a, __m128 b); +int _mm_comile_ss(__m128 a, __m128 b); +int _mm_comigt_ss(__m128 a, __m128 b); +int _mm_comige_ss(__m128 a, __m128 b); +int _mm_comineq_ss(__m128 a, __m128 b); +int _mm_ucomieq_ss(__m128 a, __m128 b); +int _mm_ucomilt_ss(__m128 a, __m128 b); +int _mm_ucomile_ss(__m128 a, __m128 b); +int _mm_ucomigt_ss(__m128 a, __m128 b); +int _mm_ucomige_ss(__m128 a, __m128 b); +int _mm_ucomineq_ss(__m128 a, __m128 b); +int _mm_cvt_ss2si(__m128 a); +int _mm_cvtt_ss2si(__m128 a); +__m128 _mm_cvt_si2ss(__m128 a, int b); +#ifdef _M_IX86 +__m64 _mm_cvt_ps2pi(__m128 a); +__m64 _mm_cvtt_ps2pi(__m128 a); +__m128 _mm_cvt_pi2ps(__m128 a, __m64 b); +#endif +__m128 _mm_shuffle_ps(__m128 a, __m128 b, unsigned int imm8); +__m128 _mm_unpackhi_ps(__m128 a, __m128 b); +__m128 _mm_unpacklo_ps(__m128 a, __m128 b); +__m128 _mm_loadh_pi(__m128 a, __m64 const* p); +void _mm_storeh_pi(__m64* p, __m128 a); +__m128 _mm_movehl_ps(__m128 a, __m128 b); +__m128 _mm_movelh_ps(__m128 a, __m128 b); +__m128 _mm_loadl_pi(__m128 a, __m64 const* p); +void _mm_storel_pi(__m64* p, __m128 a); +int _mm_movemask_ps(__m128 a); unsigned int _mm_getcsr(void); +void _mm_setcsr(unsigned int a); +__m128 _mm_set_ss(float a); +__m128 _mm_set_ps1(float a); +__m128 _mm_load_ss(float const* p); +__m128 _mm_load_ps1(float const* p); +__m128 _mm_load_ps(float const* p); +__m128 _mm_loadu_ps(float const* p); +__m128 _mm_loadr_ps(float const* p); +__m128 _mm_set_ps(float e3, float e2, float e1, float e0); +__m128 _mm_setr_ps(float e3, float e2, float e1, float e0); +void _mm_store_ss(float* p, __m128 a); +float _mm_cvtss_f32(__m128 a); +void _mm_store_ps(float* p, __m128 a); +void _mm_storeu_ps(float* p, __m128 a); +void _mm_store_ps1(float* p, __m128 a); +void _mm_storer_ps(float* p, __m128 a); +__m128 _mm_move_ss(__m128 a, __m128 b); +#ifdef _M_IX86 +int _m_pextrw(__m64 a, int imm8); +__m64 _m_pinsrw(__m64 a, int i, int imm8); +__m64 _m_pmaxsw(__m64 a, __m64 b); +__m64 _m_pmaxub(__m64 a, __m64 b); +__m64 _m_pminsw(__m64 a, __m64 b); +__m64 _m_pminub(__m64 a, __m64 b); +int _m_pmovmskb(__m64 a); +__m64 _m_pmulhuw(__m64 a, __m64 b); +__m64 _m_pshufw(__m64 a, int imm8); +void _m_maskmovq(__m64 a, __m64 b, char*); +__m64 _m_pavgb(__m64 a, __m64 b); +__m64 _m_pavgw(__m64 a, __m64 b); +__m64 _m_psadbw(__m64 a, __m64 b); +void _mm_stream_pi(__m64* p, __m64 a); +#endif +void _mm_stream_ps(float* p, __m128 a); +void _mm_sfence(void); +#ifdef _M_AMD64 +__int64 _mm_cvtss_si64(__m128 a); +__int64 _mm_cvttss_si64(__m128 a); +__m128 _mm_cvtsi64_ss(__m128 a, __int64 b); +#endif + +/* Alternate names */ +#define _mm_cvtss_si32 _mm_cvt_ss2si +#define _mm_cvttss_si32 _mm_cvtt_ss2si +#define _mm_cvtsi32_ss _mm_cvt_si2ss +#define _mm_set1_ps _mm_set_ps1 +#define _mm_load1_ps _mm_load_ps1f +#define _mm_store1_ps _mm_store_ps1 +#define _mm_cvtps_pi32 _mm_cvt_ps2pi +#define _mm_cvttps_pi32 _mm_cvtt_ps2pi +#define _mm_cvtpi32_ps _mm_cvt_pi2ps +#define _mm_extract_pi16 _m_pextrw +#define _mm_insert_pi16 _m_pinsrw +#define _mm_max_pi16 _m_pmaxsw +#define _mm_max_pu8 _m_pmaxub +#define _mm_min_pi16 _m_pminsw +#define _mm_min_pu8 _m_pminub +#define _mm_movemask_pi8 _m_pmovmskb +#define _mm_mulhi_pu16 _m_pmulhuw +#define _mm_shuffle_pi16 _m_pshufw +#define _mm_maskmove_si64 _m_maskmovq +#define _mm_avg_pu8 _m_pavgb +#define _mm_avg_pu16 _m_pavgw +#define _mm_sad_pu8 _m_psadbw + +#ifdef _M_IX86 +/* Inline functions from Clang: https://github.com/llvm/llvm-project/blob/main/clang/lib/Headers/xmmintrin.h */ + +__ATTRIBUTE_SSE__ +static __inline __m128 _mm_cvtpi16_ps(__m64 __a) +{ + __m64 __b, __c; + __m128 __r; + + __b = _mm_setzero_si64(); + __b = _mm_cmpgt_pi16(__b, __a); + __c = _mm_unpackhi_pi16(__a, __b); + __r = _mm_setzero_ps(); + __r = _mm_cvtpi32_ps(__r, __c); + __r = _mm_movelh_ps(__r, __r); + __c = _mm_unpacklo_pi16(__a, __b); + __r = _mm_cvtpi32_ps(__r, __c); + + return __r; +} + +__ATTRIBUTE_SSE__ +static __inline __m128 _mm_cvtpu16_ps(__m64 __a) +{ + __m64 __b, __c; + __m128 __r; + + __b = _mm_setzero_si64(); + __c = _mm_unpackhi_pi16(__a, __b); + __r = _mm_setzero_ps(); + __r = _mm_cvtpi32_ps(__r, __c); + __r = _mm_movelh_ps(__r, __r); + __c = _mm_unpacklo_pi16(__a, __b); + __r = _mm_cvtpi32_ps(__r, __c); + + return __r; +} + +__ATTRIBUTE_SSE__ +static __inline __m128 _mm_cvtpi8_ps(__m64 __a) +{ + __m64 __b; + + __b = _mm_setzero_si64(); + __b = _mm_cmpgt_pi8(__b, __a); + __b = _mm_unpacklo_pi8(__a, __b); + + return _mm_cvtpi16_ps(__b); +} + +__ATTRIBUTE_SSE__ +static __inline __m128 _mm_cvtpu8_ps(__m64 __a) +{ + __m64 __b; + + __b = _mm_setzero_si64(); + __b = _mm_unpacklo_pi8(__a, __b); + + return _mm_cvtpi16_ps(__b); +} + +__ATTRIBUTE_SSE__ +static __inline __m128 _mm_cvtpi32x2_ps(__m64 __a, __m64 __b) +{ + __m128 __c; + + __c = _mm_setzero_ps(); + __c = _mm_cvtpi32_ps(__c, __b); + __c = _mm_movelh_ps(__c, __c); + + return _mm_cvtpi32_ps(__c, __a); +} + +__ATTRIBUTE_SSE__ +static __inline __m64 _mm_cvtps_pi16(__m128 __a) +{ + __m64 __b, __c; + + __b = _mm_cvtps_pi32(__a); + __a = _mm_movehl_ps(__a, __a); + __c = _mm_cvtps_pi32(__a); + + return _mm_packs_pi32(__b, __c); +} + +__ATTRIBUTE_SSE__ +static __inline __m64 _mm_cvtps_pi8(__m128 __a) +{ + __m64 __b, __c; + + __b = _mm_cvtps_pi16(__a); + __c = _mm_setzero_si64(); + + return _mm_packs_pi16(__b, __c); +} + +#endif /* _M_IX86 */ + +/* Transpose the 4x4 matrix composed of row[0-3]. */ +#define _MM_TRANSPOSE4_PS(row0, row1, row2, row3) \ +do { \ + __m128 t0 = _mm_unpacklo_ps(row0, row1); \ + __m128 t1 = _mm_unpacklo_ps(row2, row3); \ + __m128 t2 = _mm_unpackhi_ps(row0, row1); \ + __m128 t3 = _mm_unpackhi_ps(row2, row3); \ + (row0) = _mm_movelh_ps(t0, t1); \ + (row1) = _mm_movehl_ps(t1, t0); \ + (row2) = _mm_movelh_ps(t2, t3); \ + (row3) = _mm_movehl_ps(t3, t2); \ +} while (0) + +#define _MM_GET_EXCEPTION_STATE() \ + (_mm_getcsr() & _MM_EXCEPT_MASK) + +#define _MM_GET_EXCEPTION_MASK() \ + (_mm_getcsr() & _MM_MASK_MASK) + +#define _MM_GET_ROUNDING_MODE() \ + (_mm_getcsr() & _MM_ROUND_MASK) + +#define _MM_GET_FLUSH_ZERO_MODE() \ + (_mm_getcsr() & _MM_FLUSH_ZERO_MASK) + +#define _MM_SET_EXCEPTION_STATE(__mask) \ + _mm_setcsr((_mm_getcsr() & ~_MM_EXCEPT_MASK) | (__mask)) + +#define _MM_SET_EXCEPTION_MASK(__mask) \ + _mm_setcsr((_mm_getcsr() & ~_MM_MASK_MASK) | (__mask)) + +#define _MM_SET_ROUNDING_MODE(__mode) \ + _mm_setcsr((_mm_getcsr() & ~_MM_ROUND_MASK) | (__mode)) + +#define _MM_SET_FLUSH_ZERO_MODE(__mode) \ + _mm_setcsr((_mm_getcsr() & ~_MM_FLUSH_ZERO_MASK) | (__mode)) + +/* Use intrinsics on MSVC */ +#if defined(_MSC_VER) && !defined(__clang__) +#pragma intrinsic(_mm_prefetch) +#pragma intrinsic(_mm_setzero_ps) +#pragma intrinsic(_mm_add_ss) +#pragma intrinsic(_mm_sub_ss) +#pragma intrinsic(_mm_mul_ss) +#pragma intrinsic(_mm_div_ss) +#pragma intrinsic(_mm_sqrt_ss) +#pragma intrinsic(_mm_rcp_ss) +#pragma intrinsic(_mm_rsqrt_ss) +#pragma intrinsic(_mm_min_ss) +#pragma intrinsic(_mm_max_ss) +#pragma intrinsic(_mm_add_ps) +#pragma intrinsic(_mm_sub_ps) +#pragma intrinsic(_mm_mul_ps) +#pragma intrinsic(_mm_div_ps) +#pragma intrinsic(_mm_sqrt_ps) +#pragma intrinsic(_mm_rcp_ps) +#pragma intrinsic(_mm_rsqrt_ps) +#pragma intrinsic(_mm_min_ps) +#pragma intrinsic(_mm_max_ps) +#pragma intrinsic(_mm_and_ps) +#pragma intrinsic(_mm_andnot_ps) +#pragma intrinsic(_mm_or_ps) +#pragma intrinsic(_mm_xor_ps) +#pragma intrinsic(_mm_cmpeq_ss) +#pragma intrinsic(_mm_cmplt_ss) +#pragma intrinsic(_mm_cmple_ss) +#pragma intrinsic(_mm_cmpgt_ss) +#pragma intrinsic(_mm_cmpge_ss) +#pragma intrinsic(_mm_cmpneq_ss) +#pragma intrinsic(_mm_cmpnlt_ss) +#pragma intrinsic(_mm_cmpnle_ss) +#pragma intrinsic(_mm_cmpngt_ss) +#pragma intrinsic(_mm_cmpnge_ss) +#pragma intrinsic(_mm_cmpord_ss) +#pragma intrinsic(_mm_cmpunord_ss) +#pragma intrinsic(_mm_cmpeq_ps) +#pragma intrinsic(_mm_cmplt_ps) +#pragma intrinsic(_mm_cmple_ps) +#pragma intrinsic(_mm_cmpgt_ps) +#pragma intrinsic(_mm_cmpge_ps) +#pragma intrinsic(_mm_cmpneq_ps) +#pragma intrinsic(_mm_cmpnlt_ps) +#pragma intrinsic(_mm_cmpnle_ps) +#pragma intrinsic(_mm_cmpngt_ps) +#pragma intrinsic(_mm_cmpnge_ps) +#pragma intrinsic(_mm_cmpord_ps) +#pragma intrinsic(_mm_cmpunord_ps) +#pragma intrinsic(_mm_comieq_ss) +#pragma intrinsic(_mm_comilt_ss) +#pragma intrinsic(_mm_comile_ss) +#pragma intrinsic(_mm_comigt_ss) +#pragma intrinsic(_mm_comige_ss) +#pragma intrinsic(_mm_comineq_ss) +#pragma intrinsic(_mm_ucomieq_ss) +#pragma intrinsic(_mm_ucomilt_ss) +#pragma intrinsic(_mm_ucomile_ss) +#pragma intrinsic(_mm_ucomigt_ss) +#pragma intrinsic(_mm_ucomige_ss) +#pragma intrinsic(_mm_ucomineq_ss) +#pragma intrinsic(_mm_cvt_ss2si) +#pragma intrinsic(_mm_cvtt_ss2si) +#pragma intrinsic(_mm_cvt_si2ss) +#ifdef _M_IX86 +#pragma intrinsic(_mm_cvt_ps2pi) +#pragma intrinsic(_mm_cvtt_ps2pi) +#pragma intrinsic(_mm_cvt_pi2ps) +#endif // _M_IX86 +#pragma intrinsic(_mm_shuffle_ps) +#pragma intrinsic(_mm_unpackhi_ps) +#pragma intrinsic(_mm_unpacklo_ps) +#pragma intrinsic(_mm_loadh_pi) +#pragma intrinsic(_mm_storeh_pi) +#pragma intrinsic(_mm_movehl_ps) +#pragma intrinsic(_mm_movelh_ps) +#pragma intrinsic(_mm_loadl_pi) +#pragma intrinsic(_mm_storel_pi) +#pragma intrinsic(_mm_movemask_ps) #pragma intrinsic(_mm_getcsr) -void _mm_setcsr(unsigned int); #pragma intrinsic(_mm_setcsr) +#pragma intrinsic(_mm_set_ss) +#pragma intrinsic(_mm_set_ps1) +#pragma intrinsic(_mm_load_ss) +#pragma intrinsic(_mm_load_ps1) +#pragma intrinsic(_mm_load_ps) +#pragma intrinsic(_mm_loadu_ps) +#pragma intrinsic(_mm_loadr_ps) +#pragma intrinsic(_mm_set_ps) +#pragma intrinsic(_mm_setr_ps) +#pragma intrinsic(_mm_store_ss) +#pragma intrinsic(_mm_cvtss_f32) +#pragma intrinsic(_mm_store_ps) +#pragma intrinsic(_mm_storeu_ps) +#pragma intrinsic(_mm_store_ps1) +#pragma intrinsic(_mm_storer_ps) +#pragma intrinsic(_mm_move_ss) +#ifdef _M_IX86 +#pragma intrinsic(_m_pextrw) +#pragma intrinsic(_m_pinsrw) +#pragma intrinsic(_m_pmaxsw) +#pragma intrinsic(_m_pmaxub) +#pragma intrinsic(_m_pminsw) +#pragma intrinsic(_m_pminub) +#pragma intrinsic(_m_pmovmskb) +#pragma intrinsic(_m_pmulhuw) +#pragma intrinsic(_m_pshufw) +#pragma intrinsic(_m_maskmovq) +#pragma intrinsic(_m_pavgb) +#pragma intrinsic(_m_pavgw) +#pragma intrinsic(_m_psadbw) +#pragma intrinsic(_mm_stream_pi) +#endif // _M_IX86 +#pragma intrinsic(_mm_stream_ps) +#pragma intrinsic(_mm_sfence) +#ifdef _M_AMD64 +#pragma intrinsic(_mm_cvtss_si64) +#pragma intrinsic(_mm_cvttss_si64) +#pragma intrinsic(_mm_cvtsi64_ss) +#endif // _M_AMD64 -#ifndef __clang__ -#pragma intrinsic(_mm_xor_ps) -#pragma intrinsic(_mm_div_ps) -#else +#else /* _MSC_VER */ /* - * Clang implements these as inline functions in the header instead of real builtins - */ -__forceinline __m128 _mm_xor_ps(__m128 a, __m128 b) + GCC: https://github.com/gcc-mirror/gcc/blob/master/gcc/config/i386/xmmintrin.h + Clang: https://github.com/llvm/llvm-project/blob/main/clang/lib/Headers/xmmintrin.h +*/ + +/* Use inline functions on GCC/Clang */ + +#if !HAS_BUILTIN(_mm_getcsr) +__INTRIN_INLINE_SSE unsigned int _mm_getcsr(void) +{ + return __builtin_ia32_stmxcsr(); +} +#endif + +#if !HAS_BUILTIN(_mm_setcsr) +__INTRIN_INLINE_SSE void _mm_setcsr(unsigned int a) { - return (__m128)((__v4su)a ^ (__v4su)b); + __builtin_ia32_ldmxcsr(a); } +#endif -__forceinline __m128 _mm_div_ps(__m128 a, __m128 b) +__INTRIN_INLINE_SSE __m128 _mm_add_ss(__m128 __a, __m128 __b) { - return (__m128)((__v4sf)a / (__v4sf)b); + __a[0] += __b[0]; + return __a; } -#endif /* __clang__ */ -#else /* _MSC_VER */ +__INTRIN_INLINE_SSE __m128 _mm_add_ps(__m128 __a, __m128 __b) +{ + return (__m128)((__v4sf)__a + (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_sub_ss(__m128 __a, __m128 __b) +{ + __a[0] -= __b[0]; + return __a; +} + +__INTRIN_INLINE_SSE __m128 _mm_sub_ps(__m128 __a, __m128 __b) +{ + return (__m128)((__v4sf)__a - (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_mul_ss(__m128 __a, __m128 __b) +{ + __a[0] *= __b[0]; + return __a; +} + +__INTRIN_INLINE_SSE __m128 _mm_mul_ps(__m128 __a, __m128 __b) +{ + return (__m128)((__v4sf)__a * (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_div_ss(__m128 __a, __m128 __b) +{ + __a[0] /= __b[0]; + return __a; +} + +__INTRIN_INLINE_SSE __m128 _mm_div_ps(__m128 __a, __m128 __b) +{ + return (__m128)((__v4sf)__a / (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_sqrt_ss(__m128 __a) +{ + return (__m128)__builtin_ia32_sqrtss((__v4sf)__a); +} + +__INTRIN_INLINE_SSE __m128 _mm_sqrt_ps(__m128 __a) +{ + return __builtin_ia32_sqrtps((__v4sf)__a); +} + +__INTRIN_INLINE_SSE __m128 _mm_rcp_ss(__m128 __a) +{ + return (__m128)__builtin_ia32_rcpss((__v4sf)__a); +} + +__INTRIN_INLINE_SSE __m128 _mm_rcp_ps(__m128 __a) +{ + return (__m128)__builtin_ia32_rcpps((__v4sf)__a); +} + +__INTRIN_INLINE_SSE __m128 _mm_rsqrt_ss(__m128 __a) +{ + return __builtin_ia32_rsqrtss((__v4sf)__a); +} + +__INTRIN_INLINE_SSE __m128 _mm_rsqrt_ps(__m128 __a) +{ + return __builtin_ia32_rsqrtps((__v4sf)__a); +} + +__INTRIN_INLINE_SSE __m128 _mm_min_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_minss((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_min_ps(__m128 __a, __m128 __b) +{ + return __builtin_ia32_minps((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_max_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_maxss((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_max_ps(__m128 __a, __m128 __b) +{ + return __builtin_ia32_maxps((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_and_ps(__m128 __a, __m128 __b) +{ + return (__m128)((__v4su)__a & (__v4su)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_andnot_ps(__m128 __a, __m128 __b) +{ + return (__m128)(~(__v4su)__a & (__v4su)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_or_ps(__m128 __a, __m128 __b) +{ + return (__m128)((__v4su)__a | (__v4su)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_xor_ps(__m128 __a, __m128 __b) +{ + return (__m128)((__v4su)__a ^ (__v4su)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpeq_ss(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpeqss((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpeq_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpeqps((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmplt_ss(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpltss((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmplt_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpltps((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmple_ss(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpless((__v4sf)__a, (__v4sf)__b); +} -#if !defined(__INTRIN_INLINE) -# ifdef __clang__ -# define __ATTRIBUTE_ARTIFICIAL -# else -# define __ATTRIBUTE_ARTIFICIAL __attribute__((artificial)) -# endif -# define __INTRIN_INLINE extern __inline__ __attribute__((__always_inline__,__gnu_inline__)) __ATTRIBUTE_ARTIFICIAL -#endif /* !__INTRIN_INLINE */ +__INTRIN_INLINE_SSE __m128 _mm_cmple_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpleps((__v4sf)__a, (__v4sf)__b); +} -#ifndef HAS_BUILTIN +__INTRIN_INLINE_SSE __m128 _mm_cmpgt_ss(__m128 __a, __m128 __b) +{ + __v4sf temp = __builtin_ia32_cmpltss((__v4sf)__b, (__v4sf)__a); #ifdef __clang__ -#define HAS_BUILTIN(x) __has_builtin(x) + return (__m128)__builtin_shufflevector((__v4sf)__a, temp, 4, 1, 2, 3); #else -#define HAS_BUILTIN(x) 0 + return (__m128)__builtin_ia32_movss((__v4sf)__a, temp); #endif +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpgt_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpltps((__v4sf)__b, (__v4sf)__a); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpge_ss(__m128 __a, __m128 __b) +{ + __v4sf temp = __builtin_ia32_cmpless((__v4sf)__b, (__v4sf)__a); +#ifdef __clang__ + return (__m128)__builtin_shufflevector((__v4sf)__a, temp, 4, 1, 2, 3); +#else + return (__m128)__builtin_ia32_movss((__v4sf)__a, temp); #endif +} -/* - * We can't use __builtin_ia32_* functions, - * are they are only available with the -msse2 compiler switch - */ -#if !HAS_BUILTIN(_mm_getcsr) -__INTRIN_INLINE unsigned int _mm_getcsr(void) +__INTRIN_INLINE_SSE __m128 _mm_cmpge_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpleps((__v4sf)__b, (__v4sf)__a); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpneq_ss(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpneqss((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpneq_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpneqps((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpnlt_ss(__m128 __a, __m128 __b) { - unsigned int retval; - __asm__ __volatile__("stmxcsr %0" : "=m"(retval)); - return retval; + return (__m128)__builtin_ia32_cmpnltss((__v4sf)__a, (__v4sf)__b); } + +__INTRIN_INLINE_SSE __m128 _mm_cmpnlt_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpnltps((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpnle_ss(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpnless((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpnle_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpnleps((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpngt_ss(__m128 __a, __m128 __b) +{ + __v4sf temp = __builtin_ia32_cmpnltss((__v4sf)__b, (__v4sf)__a); +#ifdef __clang__ + return (__m128)__builtin_shufflevector((__v4sf)__a, temp, 4, 1, 2, 3); +#else + return (__m128)__builtin_ia32_movss((__v4sf)__a, temp); #endif +} -#if !HAS_BUILTIN(_mm_setcsr) -__INTRIN_INLINE void _mm_setcsr(unsigned int val) +__INTRIN_INLINE_SSE __m128 _mm_cmpngt_ps(__m128 __a, __m128 __b) { - __asm__ __volatile__("ldmxcsr %0" : : "m"(val)); + return (__m128)__builtin_ia32_cmpnltps((__v4sf)__b, (__v4sf)__a); } + +__INTRIN_INLINE_SSE __m128 _mm_cmpnge_ss(__m128 __a, __m128 __b) +{ + __v4sf temp = (__v4sf)__builtin_ia32_cmpnless((__v4sf)__b, (__v4sf)__a); +#ifdef __clang__ + return (__m128)__builtin_shufflevector((__v4sf)__a, temp, 4, 1, 2, 3); +#else + return (__m128)__builtin_ia32_movss((__v4sf)__a, temp); #endif +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpnge_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpnleps((__v4sf)__b, (__v4sf)__a); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpord_ss(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpordss((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpord_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpordps((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpunord_ss(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpunordss((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE __m128 _mm_cmpunord_ps(__m128 __a, __m128 __b) +{ + return (__m128)__builtin_ia32_cmpunordps((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_comieq_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_comieq((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_comilt_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_comilt((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_comile_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_comile((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_comigt_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_comigt((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_comige_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_comige((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_comineq_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_comineq((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_ucomieq_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_ucomieq((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_ucomilt_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_ucomilt((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_ucomile_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_ucomile((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_ucomigt_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_ucomigt((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_ucomige_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_ucomige((__v4sf)__a, (__v4sf)__b); +} + +__INTRIN_INLINE_SSE int _mm_ucomineq_ss(__m128 __a, __m128 __b) +{ + return __builtin_ia32_ucomineq((__v4sf)__a, (__v4sf)__b); +} + +// _mm_cvt_ss2si +__INTRIN_INLINE_SSE int _mm_cvtss_si32(__m128 __a) +{ + return __builtin_ia32_cvtss2si((__v4sf)__a); +} + +#ifdef _M_AMD64 +__INTRIN_INLINE_SSE long long _mm_cvtss_si64(__m128 __a) +{ + return __builtin_ia32_cvtss2si64((__v4sf)__a); +} +#endif + +// _mm_cvt_ps2pi +__INTRIN_INLINE_SSE __m64 _mm_cvtps_pi32(__m128 __a) +{ + return (__m64)__builtin_ia32_cvtps2pi((__v4sf)__a); +} + +// _mm_cvtt_ss2si +__INTRIN_INLINE_SSE int _mm_cvttss_si32(__m128 __a) +{ + return __builtin_ia32_cvttss2si((__v4sf)__a); +} + +#ifdef _M_AMD64 +__INTRIN_INLINE_SSE long long _mm_cvttss_si64(__m128 __a) +{ + return __builtin_ia32_cvttss2si64((__v4sf)__a); +} +#endif + +// _mm_cvtt_ps2pi +__INTRIN_INLINE_SSE __m64 _mm_cvttps_pi32(__m128 __a) +{ + return (__m64)__builtin_ia32_cvttps2pi((__v4sf)__a); +} + +// _mm_cvt_si2ss +__INTRIN_INLINE_SSE __m128 _mm_cvtsi32_ss(__m128 __a, int __b) +{ + __a[0] = __b; + return __a; +} + +#ifdef _M_AMD64 +__INTRIN_INLINE_SSE __m128 _mm_cvtsi64_ss(__m128 __a, long long __b) +{ + __a[0] = __b; + return __a; +} +#endif + +// _mm_cvt_pi2ps +__INTRIN_INLINE_SSE __m128 _mm_cvtpi32_ps(__m128 __a, __m64 __b) +{ + return __builtin_ia32_cvtpi2ps((__v4sf)__a, (__v2si)__b); +} + +__INTRIN_INLINE_SSE float _mm_cvtss_f32(__m128 __a) +{ + return __a[0]; +} + +__INTRIN_INLINE_SSE __m128 _mm_loadh_pi(__m128 __a, const __m64 *__p) +{ +#ifdef __clang__ + typedef float __mm_loadh_pi_v2f32 __attribute__((__vector_size__(8))); + struct __mm_loadh_pi_struct { + __mm_loadh_pi_v2f32 __u; + } __attribute__((__packed__, __may_alias__)); + __mm_loadh_pi_v2f32 __b = ((const struct __mm_loadh_pi_struct*)__p)->__u; + __m128 __bb = __builtin_shufflevector(__b, __b, 0, 1, 0, 1); + return __builtin_shufflevector(__a, __bb, 0, 1, 4, 5); +#else + return (__m128)__builtin_ia32_loadhps(__a, __p); +#endif +} + +__INTRIN_INLINE_SSE __m128 _mm_loadl_pi(__m128 __a, const __m64 *__p) +{ +#ifdef __clang__ + typedef float __mm_loadl_pi_v2f32 __attribute__((__vector_size__(8))); + struct __mm_loadl_pi_struct { + __mm_loadl_pi_v2f32 __u; + } __attribute__((__packed__, __may_alias__)); + __mm_loadl_pi_v2f32 __b = ((const struct __mm_loadl_pi_struct*)__p)->__u; + __m128 __bb = __builtin_shufflevector(__b, __b, 0, 1, 0, 1); + return __builtin_shufflevector(__a, __bb, 4, 5, 2, 3); +#else + return (__m128)__builtin_ia32_loadlps(__a, __p); +#endif +} + +__INTRIN_INLINE_SSE __m128 _mm_load_ss(const float *__p) +{ + return _mm_set_ss(*__p); +} + +// _mm_load_ps1 +__INTRIN_INLINE_SSE __m128 _mm_load1_ps(const float *__p) +{ + return _mm_set1_ps(*__p); +} + +__INTRIN_INLINE_SSE __m128 _mm_load_ps(const float *__p) +{ + return *(const __m128*)__p; +} + +__INTRIN_INLINE_SSE __m128 _mm_loadu_ps(const float *__p) +{ + struct __loadu_ps { + __m128_u __v; + } __attribute__((__packed__, __may_alias__)); + return ((const struct __loadu_ps*)__p)->__v; +} + +__INTRIN_INLINE_SSE __m128 _mm_loadr_ps(const float *__p) +{ + __m128 __a = _mm_load_ps(__p); +#ifdef __clang__ + return __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 3, 2, 1, 0); +#else + return (__m128)__builtin_ia32_shufps(__a, __a, _MM_SHUFFLE(0,1,2,3)); +#endif +} + +__INTRIN_INLINE_SSE __m128 _mm_undefined_ps(void) +{ +#ifdef __clang__ + return (__m128)__builtin_ia32_undef128(); +#else + __m128 undef = undef; + return undef; +#endif +} + +__INTRIN_INLINE_SSE __m128 _mm_set_ss(float __w) +{ + return __extension__ (__m128){ __w, 0, 0, 0 }; +} + +// _mm_set_ps1 +__INTRIN_INLINE_SSE __m128 _mm_set1_ps(float __w) +{ + return __extension__ (__m128){ __w, __w, __w, __w }; +} + +__INTRIN_INLINE_SSE __m128 _mm_set_ps(float __z, float __y, float __x, float __w) +{ + return __extension__ (__m128){ __w, __x, __y, __z }; +} + +__INTRIN_INLINE_SSE __m128 _mm_setr_ps(float __z, float __y, float __x, float __w) +{ + return __extension__ (__m128){ __z, __y, __x, __w }; +} + +__INTRIN_INLINE_SSE __m128 _mm_setzero_ps(void) +{ + return __extension__ (__m128){ 0, 0, 0, 0 }; +} + +__INTRIN_INLINE_SSE void _mm_storeh_pi(__m64 *__p, __m128 __a) +{ +#ifdef __clang__ + typedef float __mm_storeh_pi_v2f32 __attribute__((__vector_size__(8))); + struct __mm_storeh_pi_struct { + __mm_storeh_pi_v2f32 __u; + } __attribute__((__packed__, __may_alias__)); + ((struct __mm_storeh_pi_struct*)__p)->__u = __builtin_shufflevector(__a, __a, 2, 3); +#else + __builtin_ia32_storehps(__p, __a); +#endif +} + +__INTRIN_INLINE_SSE void _mm_storel_pi(__m64 *__p, __m128 __a) +{ +#ifdef __clang__ + typedef float __mm_storeh_pi_v2f32 __attribute__((__vector_size__(8))); + struct __mm_storeh_pi_struct { + __mm_storeh_pi_v2f32 __u; + } __attribute__((__packed__, __may_alias__)); + ((struct __mm_storeh_pi_struct*)__p)->__u = __builtin_shufflevector(__a, __a, 0, 1); +#else + __builtin_ia32_storelps(__p, __a); +#endif +} + +__INTRIN_INLINE_SSE void _mm_store_ss(float *__p, __m128 __a) +{ + *__p = ((__v4sf)__a)[0]; +} + +__INTRIN_INLINE_SSE void _mm_storeu_ps(float *__p, __m128 __a) +{ + *(__m128_u *)__p = __a; +} + +__INTRIN_INLINE_SSE void _mm_store_ps(float *__p, __m128 __a) +{ + *(__m128*)__p = __a; +} + +// _mm_store_ps1 +__INTRIN_INLINE_SSE void _mm_store1_ps(float *__p, __m128 __a) +{ + // FIXME: Should we use a temp instead? +#ifdef __clang__ + __a = __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 0, 0, 0, 0); +#else + __a = __builtin_ia32_shufps(__a, __a, _MM_SHUFFLE(0,0,0,0)); +#endif + _mm_store_ps(__p, __a); +} + +__INTRIN_INLINE_SSE void _mm_storer_ps(float *__p, __m128 __a) +{ +#ifdef __clang__ + __m128 __tmp = __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 3, 2, 1, 0); +#else + __m128 __tmp = __builtin_ia32_shufps(__a, __a, _MM_SHUFFLE(0,1,2,3)); +#endif + _mm_store_ps(__p, __tmp); +} + +/* GCC / Clang specific consants */ +#define _MM_HINT_NTA_ALT 0 +#define _MM_HINT_T0_ALT 3 +#define _MM_HINT_T1_ALT 2 +#define _MM_HINT_T2_ALT 1 +#define _MM_HINT_ENTA_ALT 4 + +// These are not supported yet +//#define _MM_HINT_ET0_ALT 7 +//#define _MM_HINT_ET1_ALT 6 +//#define _MM_HINT_ET2_ALT 5 + +#define _MM_HINT_MS_TO_ALT(sel) \ + (((sel) == _MM_HINT_NTA) ? _MM_HINT_NTA_ALT : \ + ((sel) == _MM_HINT_T0) ? _MM_HINT_T0_ALT : \ + ((sel) == _MM_HINT_T1) ? _MM_HINT_T1_ALT : \ + ((sel) == _MM_HINT_T2) ? _MM_HINT_T2_ALT : \ + ((sel) == _MM_HINT_ENTA) ? _MM_HINT_ENTA_ALT : 0) + +#ifdef _MSC_VER1 + +/* On clang-cl we have an intrinsic, but the constants are different */ +#pragma intrinsic(_mm_prefetch) +#define _mm_prefetch(p, sel) _mm_prefetch(p, _MM_HINT_MS_TO_ALT(sel)) + +#else /* _MSC_VER */ + +#define _mm_prefetch(p, sel) \ + __builtin_prefetch((const void *)(p), (_MM_HINT_MS_TO_ALT(sel) >> 2) & 1, _MM_HINT_MS_TO_ALT(sel) & 0x3) + #endif /* _MSC_VER */ -/* Alternate names */ -#define _mm_cvtss_si32 _mm_cvt_ss2si +__INTRIN_INLINE_SSE void _mm_stream_pi(__m64 *__p, __m64 __a) +{ +#ifdef __clang__ + __builtin_ia32_movntq((__v1di*)__p, __a); +#else + __builtin_ia32_movntq((long long unsigned int *)__p, (long long unsigned int)__a); +#endif +} -#ifdef __cplusplus +__INTRIN_INLINE_SSE void _mm_stream_ps(float *__p, __m128 __a) +{ +#ifdef __clang__ + __builtin_nontemporal_store((__v4sf)__a, (__v4sf*)__p); +#else + __builtin_ia32_movntps(__p, (__v4sf)__a); +#endif +} + +#if !HAS_BUILTIN(_mm_sfence) +__INTRIN_INLINE_SSE void _mm_sfence(void) +{ + __builtin_ia32_sfence(); +} +#endif + +#ifdef __clang__ +#define _m_pextrw(a, n) \ + ((int)__builtin_ia32_vec_ext_v4hi((__v4hi)a, (int)n)) + +#define _m_pinsrw(a, d, n) \ + ((__m64)__builtin_ia32_vec_set_v4hi((__v4hi)a, (int)d, (int)n)) +#else +// _m_pextrw +__INTRIN_INLINE_SSE int _mm_extract_pi16(__m64 const __a, int const __n) +{ + return (unsigned short)__builtin_ia32_vec_ext_v4hi((__v4hi)__a, __n); +} + +// _m_pinsrw +__INTRIN_INLINE_SSE __m64 _mm_insert_pi16 (__m64 const __a, int const __d, int const __n) +{ + return (__m64)__builtin_ia32_vec_set_v4hi ((__v4hi)__a, __d, __n); +} + +#endif + +// _m_pmaxsw +__INTRIN_INLINE_SSE __m64 _mm_max_pi16(__m64 __a, __m64 __b) +{ + return (__m64)__builtin_ia32_pmaxsw((__v4hi)__a, (__v4hi)__b); +} + +// _m_pmaxub +__INTRIN_INLINE_SSE __m64 _mm_max_pu8(__m64 __a, __m64 __b) +{ + return (__m64)__builtin_ia32_pmaxub((__v8qi)__a, (__v8qi)__b); +} + +// _m_pminsw +__INTRIN_INLINE_SSE __m64 _mm_min_pi16(__m64 __a, __m64 __b) +{ + return (__m64)__builtin_ia32_pminsw((__v4hi)__a, (__v4hi)__b); +} + +// _m_pminub +__INTRIN_INLINE_SSE __m64 _mm_min_pu8(__m64 __a, __m64 __b) +{ + return (__m64)__builtin_ia32_pminub((__v8qi)__a, (__v8qi)__b); +} + +// _m_pmovmskb +__INTRIN_INLINE_SSE int _mm_movemask_pi8(__m64 __a) +{ + return __builtin_ia32_pmovmskb((__v8qi)__a); +} + +// _m_pmulhuw +__INTRIN_INLINE_SSE __m64 _mm_mulhi_pu16(__m64 __a, __m64 __b) +{ + return (__m64)__builtin_ia32_pmulhuw((__v4hi)__a, (__v4hi)__b); +} + +#ifdef __clang__ +#define _m_pshufw(a, n) \ + ((__m64)__builtin_ia32_pshufw((__v4hi)(__m64)(a), (n))) +#else +// _m_pshufw +__INTRIN_INLINE_MMX __m64 _mm_shuffle_pi16 (__m64 __a, int const __n) +{ + return (__m64) __builtin_ia32_pshufw ((__v4hi)__a, __n); } #endif -/* _mm_prefetch constants */ -#define _MM_HINT_T0 1 -#define _MM_HINT_T1 2 -#define _MM_HINT_T2 3 -#define _MM_HINT_NTA 0 -#define _MM_HINT_ET1 6 +// _m_maskmovq +__INTRIN_INLINE_SSE void _mm_maskmove_si64(__m64 __d, __m64 __n, char *__p) +{ + __builtin_ia32_maskmovq((__v8qi)__d, (__v8qi)__n, __p); +} + +// _m_pavgb +__INTRIN_INLINE_SSE __m64 _mm_avg_pu8(__m64 __a, __m64 __b) +{ + return (__m64)__builtin_ia32_pavgb((__v8qi)__a, (__v8qi)__b); +} + +// _m_pavgw +__INTRIN_INLINE_SSE __m64 _mm_avg_pu16(__m64 __a, __m64 __b) +{ + return (__m64)__builtin_ia32_pavgw((__v4hi)__a, (__v4hi)__b); +} + +// _m_psadbw +__INTRIN_INLINE_SSE __m64 _mm_sad_pu8(__m64 __a, __m64 __b) +{ + return (__m64)__builtin_ia32_psadbw((__v8qi)__a, (__v8qi)__b); +} +#endif // __GNUC__ + +#ifdef __cplusplus +} +#endif // __cplusplus #endif /* _INCLUDED_MM2 */

1 0

[reactos] 02/03: [CRT] Implement mmintrin.h
by Timo Kreuzer 10 Jun '22

10 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=9c8a2bbc8161810dbe6f8… commit 9c8a2bbc8161810dbe6f866be3482988239ee472 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Sat Jun 4 11:07:44 2022 +0200 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Fri Jun 10 23:21:41 2022 +0200 [CRT] Implement mmintrin.h This includes inline functions for GCC/Clang. --- sdk/include/crt/mmintrin.h | 655 ++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 651 insertions(+), 4 deletions(-) diff --git a/sdk/include/crt/mmintrin.h b/sdk/include/crt/mmintrin.h index 3b1b313a643..61a1427e6dc 100644 --- a/sdk/include/crt/mmintrin.h +++ b/sdk/include/crt/mmintrin.h @@ -1,7 +1,21 @@ -/** - * This file has no copyright assigned and is placed in the Public Domain. - * This file is part of the w64 mingw-runtime package. - * No warranty is given; refer to the file DISCLAIMER within this package. +/* + * mmintrin.h + * + * This file is part of the ReactOS CRT package. + * + * Contributors: + * Timo Kreuzer (timo.kreuzer(a)reactos.org) + * + * THIS SOFTWARE IS NOT COPYRIGHTED + * + * This source code is offered for use in the public domain. You may + * use, modify or distribute it freely. + * + * This code is distributed in the hope that it will be useful but + * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY + * DISCLAIMED. This includes but is not limited to warranties of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * */ #pragma once @@ -10,6 +24,639 @@ #include <crtdefs.h> +#ifdef __cplusplus +extern "C" { +#endif +#ifdef _MSC_VER +#define DECLSPEC_INTRINTYPE __declspec(intrin_type) +#else +#define DECLSPEC_INTRINTYPE +#endif + +#if defined(_MSC_VER) && !defined(__clang__) + + typedef union DECLSPEC_INTRINTYPE _CRT_ALIGN(8) __m64 + { + unsigned __int64 m64_u64; + float m64_f32[2]; + __int8 m64_i8[8]; + __int16 m64_i16[4]; + __int32 m64_i32[2]; + __int64 m64_i64; + unsigned __int8 m64_u8[8]; + unsigned __int16 m64_u16[4]; + unsigned __int32 m64_u32[2]; + } __m64; + +#else /* _MSC_VER */ + + typedef long long __v1di __attribute__((__vector_size__(8))); + typedef int __v2si __attribute__((__vector_size__(8))); + typedef short __v4hi __attribute__((__vector_size__(8))); + typedef char __v8qi __attribute__((__vector_size__(8))); + + typedef float __m64 __attribute__((__vector_size__(8), __aligned__(16))); + +#ifdef __clang__ +#define __INTRIN_INLINE_MMX __INTRIN_INLINE __attribute__((__target__("mmx"),__min_vector_width__(64))) +#else +#define __INTRIN_INLINE_MMX __INTRIN_INLINE __attribute__((__target__("mmx"))) +#endif + +#endif /* _MSC_VER */ + +#ifdef _M_IX86 + +void _m_empty(void); +__m64 _m_from_int(int i); +int _m_to_int(__m64 m); +__m64 _m_packsswb(__m64 a, __m64 b); +__m64 _m_packssdw(__m64 a, __m64 b); +__m64 _m_packuswb(__m64 a, __m64 b); +__m64 _m_punpckhbw(__m64 a, __m64 b); +__m64 _m_punpckhwd(__m64 a, __m64 b); +__m64 _m_punpckhdq(__m64 a, __m64 b); +__m64 _m_punpcklbw(__m64 a, __m64 b); +__m64 _m_punpcklwd(__m64 a, __m64 b); +__m64 _m_punpckldq(__m64 a, __m64 b); +__m64 _m_paddb(__m64 a, __m64 b); +__m64 _m_paddw(__m64 a, __m64 b); +__m64 _m_paddd(__m64 a, __m64 b); +__m64 _m_paddsb(__m64 a, __m64 b); +__m64 _m_paddsw(__m64 a, __m64 b); +__m64 _m_paddusb(__m64 a, __m64 b); +__m64 _m_paddusw(__m64 a, __m64 b); +__m64 _m_psubb(__m64 a, __m64 b); +__m64 _m_psubw(__m64 a, __m64 b); +__m64 _m_psubd(__m64 a, __m64 b); +__m64 _m_psubsb(__m64 a, __m64 b); +__m64 _m_psubsw(__m64 a, __m64 b); +__m64 _m_psubusb(__m64 a, __m64 b); +__m64 _m_psubusw(__m64 a, __m64 b); +__m64 _m_pmaddwd(__m64 a, __m64 b); +__m64 _m_pmulhw(__m64 a, __m64 b); +__m64 _m_pmullw(__m64 a, __m64 b); +__m64 _m_psllw(__m64 a, __m64 count); +__m64 _m_psllwi(__m64 a, int imm8); +__m64 _m_pslld(__m64 a, __m64 count); +__m64 _m_pslldi(__m64 a, int imm8); +__m64 _m_psllq(__m64 a, __m64 count); +__m64 _m_psllqi(__m64 a, int imm8); +__m64 _m_psraw(__m64 a, __m64 count); +__m64 _m_psrawi(__m64 a, int imm8); +__m64 _m_psrad(__m64 a, __m64 count); +__m64 _m_psradi(__m64 a, int imm8); +__m64 _m_psrlw(__m64 a, __m64 count); +__m64 _m_psrlwi(__m64 a, int imm8); +__m64 _m_psrld(__m64 a, __m64 count); +__m64 _m_psrldi(__m64 a, int imm8); +__m64 _m_psrlq(__m64 a, __m64 count); +__m64 _m_psrlqi(__m64 a, int imm8); +__m64 _m_pand(__m64 a, __m64 b); +__m64 _m_pandn(__m64 a, __m64 b); +__m64 _m_por(__m64 a, __m64 b); +__m64 _m_pxor(__m64 a, __m64 b); +__m64 _m_pcmpeqb(__m64 a, __m64 b); +__m64 _m_pcmpgtb(__m64 a, __m64 b); +__m64 _m_pcmpeqw(__m64 a, __m64 b); +__m64 _m_pcmpgtw(__m64 a, __m64 b); +__m64 _m_pcmpeqd(__m64 a, __m64 b); +__m64 _m_pcmpgtd(__m64 a, __m64 b); +__m64 _mm_setzero_si64(void); +__m64 _mm_set_pi32(int i1, int i0); +__m64 _mm_set_pi16(short s3, short s2, short s1, short s0); +__m64 _mm_set_pi8(char b7, char b6, char b5, char b4, + char b3, char b2, char b1, char b0); +__m64 _mm_setr_pi32(int i1, int i0); +__m64 _mm_setr_pi16(short s3, short s2, short s1, short s0); +__m64 _mm_setr_pi8(char b7, char b6, char b5, char b4, + char b3, char b2, char b1, char b0); +__m64 _mm_set1_pi32(int i); +__m64 _mm_set1_pi16(short s); +__m64 _mm_set1_pi8(char b); + +/* Alternate names */ +#define _mm_empty _m_empty +#define _mm_cvtsi32_si64 _m_from_int +#define _mm_cvtsi64_si32 _m_to_int +#define _mm_packs_pi16 _m_packsswb +#define _mm_packs_pi32 _m_packssdw +#define _mm_packs_pu16 _m_packuswb +#define _mm_unpackhi_pi8 _m_punpckhbw +#define _mm_unpackhi_pi16 _m_punpckhwd +#define _mm_unpackhi_pi32 _m_punpckhdq +#define _mm_unpacklo_pi8 _m_punpcklbw +#define _mm_unpacklo_pi16 _m_punpcklwd +#define _mm_unpacklo_pi32 _m_punpckldq +#define _mm_add_pi8 _m_paddb +#define _mm_add_pi16 _m_paddw +#define _mm_add_pi32 _m_paddd +#define _mm_adds_pi8 _m_paddsb +#define _mm_adds_pi16 _m_paddsw +#define _mm_adds_pu8 _m_paddusb +#define _mm_adds_pu16 _m_paddusw +#define _mm_sub_pi8 _m_psubb +#define _mm_sub_pi16 _m_psubw +#define _mm_sub_pi32 _m_psubd +#define _mm_subs_pi8 _m_psubsb +#define _mm_subs_pi16 _m_psubsw +#define _mm_subs_pu8 _m_psubusb +#define _mm_subs_pu16 _m_psubusw +#define _mm_madd_pi16 _m_pmaddwd +#define _mm_mulhi_pi16 _m_pmulhw +#define _mm_mullo_pi16 _m_pmullw +#define _mm_sll_pi16 _m_psllw +#define _mm_slli_pi16 _m_psllwi +#define _mm_sll_pi32 _m_pslld +#define _mm_slli_pi32 _m_pslldi +#define _mm_sll_si64 _m_psllq +#define _mm_slli_si64 _m_psllqi +#define _mm_sra_pi16 _m_psraw +#define _mm_srai_pi16 _m_psrawi +#define _mm_sra_pi32 _m_psrad +#define _mm_srai_pi32 _m_psradi +#define _mm_srl_pi16 _m_psrlw +#define _mm_srli_pi16 _m_psrlwi +#define _mm_srl_pi32 _m_psrld +#define _mm_srli_pi32 _m_psrldi +#define _mm_srl_si64 _m_psrlq +#define _mm_srli_si64 _m_psrlqi +#define _mm_and_si64 _m_pand +#define _mm_andnot_si64 _m_pandn +#define _mm_or_si64 _m_por +#define _mm_xor_si64 _m_pxor +#define _mm_cmpeq_pi8 _m_pcmpeqb +#define _mm_cmpgt_pi8 _m_pcmpgtb +#define _mm_cmpeq_pi16 _m_pcmpeqw +#define _mm_cmpgt_pi16 _m_pcmpgtw +#define _mm_cmpeq_pi32 _m_pcmpeqd +#define _mm_cmpgt_pi32 _m_pcmpgtd + +/* Use intrinsics on MSVC */ +#if defined(_MSC_VER) && !defined(__clang__) +#pragma intrinsic(_m_empty) +#pragma intrinsic(_m_from_int) +#pragma intrinsic(_m_to_int) +#pragma intrinsic(_m_packsswb) +#pragma intrinsic(_m_packssdw) +#pragma intrinsic(_m_packuswb) +#pragma intrinsic(_m_punpckhbw) +#pragma intrinsic(_m_punpckhwd) +#pragma intrinsic(_m_punpckhdq) +#pragma intrinsic(_m_punpcklbw) +#pragma intrinsic(_m_punpcklwd) +#pragma intrinsic(_m_punpckldq) +#pragma intrinsic(_m_paddb) +#pragma intrinsic(_m_paddw) +#pragma intrinsic(_m_paddd) +#pragma intrinsic(_m_paddsb) +#pragma intrinsic(_m_paddsw) +#pragma intrinsic(_m_paddusb) +#pragma intrinsic(_m_paddusw) +#pragma intrinsic(_m_psubb) +#pragma intrinsic(_m_psubw) +#pragma intrinsic(_m_psubd) +#pragma intrinsic(_m_psubsb) +#pragma intrinsic(_m_psubsw) +#pragma intrinsic(_m_psubusb) +#pragma intrinsic(_m_psubusw) +#pragma intrinsic(_m_pmaddwd) +#pragma intrinsic(_m_pmulhw) +#pragma intrinsic(_m_pmullw) +#pragma intrinsic(_m_psllw) +#pragma intrinsic(_m_psllwi) +#pragma intrinsic(_m_pslld) +#pragma intrinsic(_m_pslldi) +#pragma intrinsic(_m_psllq) +#pragma intrinsic(_m_psllqi) +#pragma intrinsic(_m_psraw) +#pragma intrinsic(_m_psrawi) +#pragma intrinsic(_m_psrad) +#pragma intrinsic(_m_psradi) +#pragma intrinsic(_m_psrlw) +#pragma intrinsic(_m_psrlwi) +#pragma intrinsic(_m_psrld) +#pragma intrinsic(_m_psrldi) +#pragma intrinsic(_m_psrlq) +#pragma intrinsic(_m_psrlqi) +#pragma intrinsic(_m_pand) +#pragma intrinsic(_m_pandn) +#pragma intrinsic(_m_por) +#pragma intrinsic(_m_pxor) +#pragma intrinsic(_m_pcmpeqb) +#pragma intrinsic(_m_pcmpgtb) +#pragma intrinsic(_m_pcmpeqw) +#pragma intrinsic(_m_pcmpgtw) +#pragma intrinsic(_m_pcmpeqd) +#pragma intrinsic(_m_pcmpgtd) +#pragma intrinsic(_mm_setzero_si64) +#pragma intrinsic(_mm_set_pi32) +#pragma intrinsic(_mm_set_pi16) +#pragma intrinsic(_mm_set_pi8) +#pragma intrinsic(_mm_setr_pi32) +#pragma intrinsic(_mm_setr_pi16) +#pragma intrinsic(_mm_setr_pi8) +#pragma intrinsic(_mm_set1_pi32) +#pragma intrinsic(_mm_set1_pi16) +#pragma intrinsic(_mm_set1_pi8) + +/* Use inline functions on GCC/Clang */ +#else // GCC / Clang Clang-CL + +/* +- GCC: https://github.com/gcc-mirror/gcc/blob/master/gcc/config/i386/mmintrin.h +- Clang: https://github.com/llvm/llvm-project/blob/main/clang/lib/Headers/mmintrin.h +*/ + +// _m_empty +__INTRIN_INLINE_MMX void _mm_empty(void) +{ + __builtin_ia32_emms(); +} + +// _m_from_int +__INTRIN_INLINE_MMX __m64 _mm_cvtsi32_si64(int i) +{ + return (__m64)__builtin_ia32_vec_init_v2si(i, 0); +} + +// _m_to_int +__INTRIN_INLINE_MMX int _mm_cvtsi64_si32(__m64 m) +{ + return __builtin_ia32_vec_ext_v2si((__v2si)m, 0); +} + +// _m_packsswb +__INTRIN_INLINE_MMX __m64 _mm_packs_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_packsswb((__v4hi)a, (__v4hi)b); +} + +// _m_packssdw +__INTRIN_INLINE_MMX __m64 _mm_packs_pi32(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_packssdw((__v2si)a, (__v2si)b); +} + +// _m_packuswb +__INTRIN_INLINE_MMX __m64 _mm_packs_pu16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_packuswb((__v4hi)a, (__v4hi)b); +} + +// _m_punpckhbw +__INTRIN_INLINE_MMX __m64 _mm_unpackhi_pi8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_punpckhbw((__v8qi)a, (__v8qi)b); +} + +// _m_punpckhwd +__INTRIN_INLINE_MMX __m64 _mm_unpackhi_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_punpckhwd((__v4hi)a, (__v4hi)b); +} + +// _m_punpckhdq +__INTRIN_INLINE_MMX __m64 _mm_unpackhi_pi32(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_punpckhdq((__v2si)a, (__v2si)b); +} + +// _m_punpcklbw +__INTRIN_INLINE_MMX __m64 _mm_unpacklo_pi8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_punpcklbw((__v8qi)a, (__v8qi)b); +} + +// _m_punpcklwd +__INTRIN_INLINE_MMX __m64 _mm_unpacklo_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_punpcklwd((__v4hi)a, (__v4hi)b); +} + +// _m_punpckldq +__INTRIN_INLINE_MMX __m64 _mm_unpacklo_pi32(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_punpckldq((__v2si)a, (__v2si)b); +} + +// _m_paddb +__INTRIN_INLINE_MMX __m64 _mm_add_pi8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_paddb((__v8qi)a, (__v8qi)b); +} + +// _m_paddw +__INTRIN_INLINE_MMX __m64 _mm_add_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_paddw((__v4hi)a, (__v4hi)b); +} + +// _m_paddd +__INTRIN_INLINE_MMX __m64 _mm_add_pi32(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_paddd((__v2si)a, (__v2si)b); +} + +// _m_paddsb +__INTRIN_INLINE_MMX __m64 _mm_adds_pi8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_paddsb((__v8qi)a, (__v8qi)b); +} + +// _m_paddsw +__INTRIN_INLINE_MMX __m64 _mm_adds_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_paddsw((__v4hi)a, (__v4hi)b); +} + +// _m_paddusb +__INTRIN_INLINE_MMX __m64 _mm_adds_pu8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_paddusb((__v8qi)a, (__v8qi)b); +} + +// _m_paddusw +__INTRIN_INLINE_MMX __m64 _mm_adds_pu16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_paddusw((__v4hi)a, (__v4hi)b); +} + +// _m_psubb +__INTRIN_INLINE_MMX __m64 _mm_sub_pi8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_psubb((__v8qi)a, (__v8qi)b); +} + +// _m_psubw +__INTRIN_INLINE_MMX __m64 _mm_sub_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_psubw((__v4hi)a, (__v4hi)b); +} + +// _m_psubd +__INTRIN_INLINE_MMX __m64 _mm_sub_pi32(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_psubd((__v2si)a, (__v2si)b); +} + +// _m_psubsb +__INTRIN_INLINE_MMX __m64 _mm_subs_pi8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_psubsb((__v8qi)a, (__v8qi)b); +} + +// _m_psubsw +__INTRIN_INLINE_MMX __m64 _mm_subs_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_psubsw((__v4hi)a, (__v4hi)b); +} + +// _m_psubusb +__INTRIN_INLINE_MMX __m64 _mm_subs_pu8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_psubusb((__v8qi)a, (__v8qi)b); +} + +// _m_psubusw +__INTRIN_INLINE_MMX __m64 _mm_subs_pu16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_psubusw((__v4hi)a, (__v4hi)b); +} + +// _m_pmaddwd +__INTRIN_INLINE_MMX __m64 _mm_madd_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pmaddwd((__v4hi)a, (__v4hi)b); +} + +// _m_pmulhw +__INTRIN_INLINE_MMX __m64 _mm_mulhi_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pmulhw((__v4hi)a, (__v4hi)b); +} + +// _m_pmullw +__INTRIN_INLINE_MMX __m64 _mm_mullo_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pmullw((__v4hi)a, (__v4hi)b); +} + +// _m_psllw +__INTRIN_INLINE_MMX __m64 _mm_sll_pi16(__m64 a, __m64 count) +{ + return (__m64)__builtin_ia32_psllw((__v4hi)a, (__v4hi)count); +} + +// _m_psllwi +__INTRIN_INLINE_MMX __m64 _mm_slli_pi16(__m64 a, int imm8) +{ + return (__m64)__builtin_ia32_psllwi((__v4hi)a, imm8); +} + +// _m_pslld +__INTRIN_INLINE_MMX __m64 _mm_sll_pi32(__m64 a, __m64 count) +{ + return (__m64)__builtin_ia32_pslld((__v2si)a, (__v2si)count); +} + +// _m_pslldi +__INTRIN_INLINE_MMX __m64 _mm_slli_pi32(__m64 a, int imm8) +{ + return (__m64)__builtin_ia32_pslldi((__v2si)a, imm8); +} + +// _m_psllq +__INTRIN_INLINE_MMX __m64 _mm_sll_si64(__m64 a, __m64 count) +{ + return (__m64)__builtin_ia32_psllq((__v1di)a, (__v1di)count); +} + +// _m_psllqi +__INTRIN_INLINE_MMX __m64 _mm_slli_si64(__m64 a, int imm8) +{ + return (__m64)__builtin_ia32_psllqi((__v1di)a, imm8); +} + +// _m_psraw +__INTRIN_INLINE_MMX __m64 _mm_sra_pi16(__m64 a, __m64 count) +{ + return (__m64)__builtin_ia32_psraw((__v4hi)a, (__v4hi)count); +} + +// _m_psrawi +__INTRIN_INLINE_MMX __m64 _mm_srai_pi16(__m64 a, int imm8) +{ + return (__m64)__builtin_ia32_psrawi((__v4hi)a, imm8); +} + +// _m_psrad +__INTRIN_INLINE_MMX __m64 _mm_sra_pi32(__m64 a, __m64 count) +{ + return (__m64)__builtin_ia32_psrad((__v2si)a, (__v2si)count); +} + +// _m_psradi +__INTRIN_INLINE_MMX __m64 _mm_srai_pi32(__m64 a, int imm8) +{ + return (__m64)__builtin_ia32_psradi((__v2si)a, imm8); +} + +// _m_psrlw +__INTRIN_INLINE_MMX __m64 _mm_srl_pi16(__m64 a, __m64 count) +{ + return (__m64)__builtin_ia32_psrlw((__v4hi)a, (__v4hi)count); +} + +// _m_psrlwi +__INTRIN_INLINE_MMX __m64 _mm_srli_pi16(__m64 a, int imm8) +{ + return (__m64)__builtin_ia32_psrlwi((__v4hi)a, imm8); +} + +// _m_psrld +__INTRIN_INLINE_MMX __m64 _mm_srl_pi32(__m64 a, __m64 count) +{ + return (__m64)__builtin_ia32_psrld((__v2si)a, (__v2si)count); +} + +// _m_psrldi +__INTRIN_INLINE_MMX __m64 _mm_srli_pi32(__m64 a, int imm8) +{ + return (__m64)__builtin_ia32_psrldi((__v2si)a, imm8); +} + +// _m_psrlq +__INTRIN_INLINE_MMX __m64 _mm_srl_si64(__m64 a, __m64 count) +{ + return (__m64)__builtin_ia32_psrlq((__v1di)a, (__v1di)count); +} + +// _m_psrlqi +__INTRIN_INLINE_MMX __m64 _mm_srli_si64(__m64 a, int imm8) +{ + return (__m64)__builtin_ia32_psrlqi((__v1di)a, imm8); +} + +// _m_pand +__INTRIN_INLINE_MMX __m64 _mm_and_si64(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pand((__v2si)a, (__v2si)b); +} + +// _m_pandn +__INTRIN_INLINE_MMX __m64 _mm_andnot_si64(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pandn((__v2si)a, (__v2si)b); +} + +// _m_por +__INTRIN_INLINE_MMX __m64 _mm_or_si64(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_por((__v2si)a, (__v2si)b); +} + +// _m_pxor +__INTRIN_INLINE_MMX __m64 _mm_xor_si64(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pxor((__v2si)a, (__v2si)b); +} + +// _m_pcmpeqb +__INTRIN_INLINE_MMX __m64 _mm_cmpeq_pi8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pcmpeqb((__v8qi)a, (__v8qi)b); +} + +// _m_pcmpgtb +__INTRIN_INLINE_MMX __m64 _mm_cmpgt_pi8(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pcmpgtb((__v8qi)a, (__v8qi)b); +} + +// _m_pcmpeqw +__INTRIN_INLINE_MMX __m64 _mm_cmpeq_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pcmpeqw((__v4hi)a, (__v4hi)b); +} + +// _m_pcmpgtw +__INTRIN_INLINE_MMX __m64 _mm_cmpgt_pi16(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pcmpgtw((__v4hi)a, (__v4hi)b); +} + +// _m_pcmpeqd +__INTRIN_INLINE_MMX __m64 _mm_cmpeq_pi32(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pcmpeqd((__v2si)a, (__v2si)b); +} + +// _m_pcmpgtd +__INTRIN_INLINE_MMX __m64 _mm_cmpgt_pi32(__m64 a, __m64 b) +{ + return (__m64)__builtin_ia32_pcmpgtd((__v2si)a, (__v2si)b); +} + +__INTRIN_INLINE_MMX __m64 _mm_setzero_si64(void) +{ + return (__m64) { 0 }; +} + +__INTRIN_INLINE_MMX __m64 _mm_set_pi32(int i1, int i0) +{ + return (__m64)__builtin_ia32_vec_init_v2si(i0, i1); +} + +__INTRIN_INLINE_MMX __m64 _mm_set_pi16(short s3, short s2, short s1, short s0) +{ + return (__m64)__builtin_ia32_vec_init_v4hi(s0, s1, s2, s3); +} + +__INTRIN_INLINE_MMX __m64 _mm_set_pi8(char b7, char b6, char b5, char b4, + char b3, char b2, char b1, char b0) +{ + return (__m64)__builtin_ia32_vec_init_v8qi(b0, b1, b2, b3, b4, b5, b6, b7); +} + +__INTRIN_INLINE_MMX __m64 _mm_setr_pi32(int i1, int i0) +{ + return _mm_set_pi32(i0, i1); +} + +__INTRIN_INLINE_MMX __m64 _mm_setr_pi16(short s3, short s2, short s1, short s0) +{ + return _mm_set_pi16(s0, s1, s2, s3); +} + +__INTRIN_INLINE_MMX __m64 _mm_setr_pi8(char b7, char b6, char b5, char b4, + char b3, char b2, char b1, char b0) +{ + return _mm_set_pi8(b7, b6, b5, b4, b3, b2, b1, b0); +} + +__INTRIN_INLINE_MMX __m64 _mm_set1_pi32(int i) +{ + return _mm_set_pi32(i, i); +} + +__INTRIN_INLINE_MMX __m64 _mm_set1_pi16(short s) +{ + return _mm_set_pi16(s, s, s, s); +} + +__INTRIN_INLINE_MMX __m64 _mm_set1_pi8(char b) +{ + return _mm_set_pi8(b, b, b, b, b, b, b, b); +} + +#endif /* __GNUC__ */ + +#endif /* _M_IX86 */ + +#ifdef __cplusplus +} +#endif #endif /* _MMINTRIN_H_INCLUDED */

1 0

[reactos] 01/03: [CRT] Move __INTRIN_INLINE to mingw32.h to be available everywhere
by Timo Kreuzer 10 Jun '22

10 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c34c5e29f00159c6b8ee7… commit c34c5e29f00159c6b8ee76d0eec8fe01ffc82386 Author: Timo Kreuzer <timo.kreuzer(a)reactos.org> AuthorDate: Thu Jan 9 20:16:43 2020 +0100 Commit: Timo Kreuzer <timo.kreuzer(a)reactos.org> CommitDate: Fri Jun 10 23:21:41 2022 +0200 [CRT] Move __INTRIN_INLINE to mingw32.h to be available everywhere Also use __attribute__((artificial)) for clang, too. --- sdk/include/crt/_mingw.h | 12 ++++++++++++ sdk/include/crt/mingw32/intrin.h | 17 ----------------- 2 files changed, 12 insertions(+), 17 deletions(-) diff --git a/sdk/include/crt/_mingw.h b/sdk/include/crt/_mingw.h index 99030d543e4..6cdec9a88e7 100644 --- a/sdk/include/crt/_mingw.h +++ b/sdk/include/crt/_mingw.h @@ -244,6 +244,18 @@ allow GCC to optimize away some EH unwind code, at least in DW2 case. */ #endif #endif /* DECLSPEC_HOTPATCH */ +#ifndef __INTRIN_INLINE +# define __INTRIN_INLINE extern __inline__ __attribute__((__always_inline__,__gnu_inline__,artificial)) +#endif + +#ifndef HAS_BUILTIN +# ifdef __clang__ +# define HAS_BUILTIN(x) __has_builtin(x) +# else +# define HAS_BUILTIN(x) 0 +# endif +#endif + #ifdef __cplusplus # define __mingw_ovr inline __cdecl #elif defined (__GNUC__) diff --git a/sdk/include/crt/mingw32/intrin.h b/sdk/include/crt/mingw32/intrin.h index c7c6b6a0d29..051199a0315 100644 --- a/sdk/include/crt/mingw32/intrin.h +++ b/sdk/include/crt/mingw32/intrin.h @@ -30,23 +30,6 @@ #ifndef RC_INVOKED -#ifndef __INTRIN_INLINE -# ifdef __clang__ -# define __ATTRIBUTE_ARTIFICIAL -# else -# define __ATTRIBUTE_ARTIFICIAL __attribute__((artificial)) -# endif -# define __INTRIN_INLINE extern __inline__ __attribute__((__always_inline__,__gnu_inline__)) __ATTRIBUTE_ARTIFICIAL -#endif - -#ifndef HAS_BUILTIN -# ifdef __clang__ -# define HAS_BUILTIN(x) __has_builtin(x) -# else -# define HAS_BUILTIN(x) 0 -# endif -#endif - #ifndef _SIZE_T_DEFINED #define _SIZE_T_DEFINED #ifdef _WIN64

1 0

[reactos] 01/01: [DISKPART] Add help text for the SETID command
by Eric Kohl 10 Jun '22

10 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=84512b7abddffe28d9b95… commit 84512b7abddffe28d9b95472635b9c2bcf4bd732 Author: Eric Kohl <eric.kohl(a)reactos.org> AuthorDate: Fri Jun 10 22:01:42 2022 +0200 Commit: Eric Kohl <eric.kohl(a)reactos.org> CommitDate: Fri Jun 10 22:02:07 2022 +0200 [DISKPART] Add help text for the SETID command --- base/system/diskpart/diskpart_msg.mc | 741 ++++++++++++++++++++++++++++++++++- 1 file changed, 732 insertions(+), 9 deletions(-) diff --git a/base/system/diskpart/diskpart_msg.mc b/base/system/diskpart/diskpart_msg.mc index 15ccd2c3117..c974c6ddc72 100644 --- a/base/system/diskpart/diskpart_msg.mc +++ b/base/system/diskpart/diskpart_msg.mc @@ -3004,31 +3004,754 @@ Example: SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 . Language=German -<Add SETID command help text here> + + Ändert das Partitionstypfeld für die Partition im Fokus. + +Syntax: SET ID={<BYTE> | <GUID>} [OVERRIDE] [NOERR] + + ID={<BYTE> | <GUID>} + + Gibt den neuen Partitionstyp an. + + Für MBR-Datenträger (Master Boot Record) können Sie ein + Partitionstypbyte im Hexadezimalformat angeben. Mit + diesem Parameter können Sie jedes Partitionstypbyte angeben, + außer Typ "0x42" (LDM-Partition). Das voranstehende "0x" wird + bei Angabe des hexadezimalen Partitionstyps ausgelassen. + + Für GPT-Datenträger (GPT = GUID-Partitionstabelle) können + Sie einen Partitionstyp-GUID für die zu erstellende Partition + angeben: Zu den erkannten GUIDs gehören: + + EFI-Systempartition: + c12a7328-f81f-11d2-ba4b-00a0c93ec93b + + Basisdatenpartition: + ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 + + Mit diesem Parameter kann jeder Partitionstyp-GUID + angegeben werden, mit Ausnahme der folgenden: + + MSR-Partition (Microsoft Reserved): + e3c9e316-0b5c-4db8-817d-f92df00215ae + + LDM-Metadatenpartition auf einem dynamischen Datenträger: + 5808c8aa-7e8f-42e0-85d2-e1e90434cfb3 + + LDM-Datenpartition auf einem dynamischen Datenträger: + af9b60a0-1431-4f62-bc68-3311714a69ad + + Clustermetadaten-Partition: + db97dba9-0840-4bae-97f0-ffb9a327c7e1 + + + Abgesehen von den erwähnten Einschränkungen überprüft + DiskPart die Gültigkeit des Partitionstyps nicht. Es wird + lediglich sichergestellt, dass es sich um ein Byte im Hexadezi- + malformat oder um einen GUID handelt + + OVERRIDE Ermöglicht DiskPart die Aufhebung der Bereitstellung + des Dateisystems auf dem Volume zu erzwingen, bevor der + Partitionstyp geändert wird. Beim Ändern des Partitionstyps + wird das Dateisystem auf dem Volume gesperrt und dessen + Bereitstellung aufgehoben. Wird dieser Parameter nicht an- + gegeben und schlägt der Aufruf zum Sperren des Dateisys- + tems fehl (da einige andere Anwendungen über ein geöffne- + tes Handle für das Volume verfügen), schlägt der gesamte + Vorgang fehl. Bei Angabe dieses Parameters wird die Auf- + hebung der Bereitstellung auch dann erzwungen, wenn der + Aufruf des Dateisystems fehlschlägt. Wird die Bereitstellung + eines Dateisystems aufgehoben, werden alle geöffneten + Handles für das Volume ungültig. + + NOERR Nur für Skripting. Bei einem Fehler wird die Verarbeitung von + Befehlen fortgesetzt, als sei der Fehler nicht aufgetreten. + Ohne NOERR-Parameter wird DiskPart bei einem Fehler mit + dem entsprechenden Fehlercode beendet. + + Ist nur für die Verwendung durch Originalgerätehersteller + (OEM, Original Equipment Manufacturer) vorgesehen. + + Damit dieser Vorgang erfolgreich ausgeführt werden kann, muss + eine Partition ausgewählt sein. + + Vorsicht: + + Das Ändern von Partitionstypfeldern mit diesem Parameter kann + dazu führen, dass der Computer nicht mehr ordnungsgemäß + funktioniert oder nicht mehr gestartet werden kann. Sofern Sie + kein Originalgerätehersteller oder IT-Fachmann sind, der mit GPT- + Datenträgern vertraut ist, sollten Sie keine Partitionstypfelder auf + GPT-Datenträgern mit diesem Parameter ändern. Verwenden Sie + stattdessen immer den Befehl "CREATE PARTITION EFI" zum + Erstellen von EFI-Systempartitionen, den Befehl "CREATE + PARTITION MSR" zum Erstellen von MSR-Partitionen und den + Befehl "CREATE PARTITION PRIMARY" (ohne diesen Parameter) + zum Erstellen von primären Partitionen auf GPT-Datenträgern. + + Dieser Befehl funktioniert weder auf dynamischen Datenträgern noch + auf MSR-Partitionen (Microsoft Reserved). + +Beispiel: + + SET ID=07 OVERRIDE + SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 . Language=Polish -<Add SETID command help text here> + Changes the partition type field for the partition with focus. + +Syntax: SET ID={<BYTE> | <GUID>} [OVERRIDE] [NOERR] + + ID={<BYTE> | <GUID>} + + Specifies the new partition type. + For master boot record (MBR) disks, you can specify a partition + type byte, in hexadecimal form, for the partition. Any + partition type byte can be specified with this parameter except + for type 0x42 (LDM partition). Note that the leading '0x' is + omitted when specifying the hexadecimal partition type. + + For GUID partition table (GPT) disks you can specify a + partition type GUID for the partition. Recognized GUIDs + include: + + EFI System partition: + c12a7328-f81f-11d2-ba4b-00a0c93ec93b + + Basic data partition: + ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 + + Any partition type GUID can be specified with this parameter + except for the following: + + Microsoft Reserved partition: + e3c9e316-0b5c-4db8-817d-f92df00215a + + LDM Metadata partition on a dynamic disk: + 5808c8aa-7e8f-42e0-85d2-e1e90434cfb3 + + LDM Data partition on a dynamic disk: + af9b60a0-1431-4f62-bc68-3311714a69ad + + Cluster Metadata partition: + db97dba9-0840-4bae-97f0-ffb9a327c7e1 + + + Other than the limitations mentioned, DiskPart otherwise does + not check the partition type for validity except to ensure that + it is a byte in hexadecimal form or a GUID. + + OVERRIDE Enables DiskPart to force the file system on the volume to + dismount before changing the partition type. When changing + the partition type, DiskPart will attempt to lock and dismount + the file system on the volume. If this parameter is not specified, + and the call to lock the file system fails, (because some other + application has an open handle to the volume), the entire + operation will fail. When this parameter is specified, the + dismount is forced even if the call to lock the file system + fails. When a file system is dismounted, all opened handles to + the volume will become invalid. + + NOERR For scripting only. When an error is encountered, DiskPart + continues to process commands as if the error did not occur. + Without the NOERR parameter, an error causes DiskPart to exit + with an error code. + + Intended for Original Equipment Manufacturer (OEM) use only. + + A partition must be selected for this operation to succeed. + + Caution: + + Changing partition type fields with this parameter might cause your + computer to fail or be unable to start up. Unless you are an OEM or an + IT professional experienced with GPT disks, do not change partition + type fields on GPT disks using this parameter. Instead, always use the + CREATE PARTITION EFI command to create EFI System partitions, the + CREATE PARTITION MSR command to create Microsoft Reserved partitions, + and the CREATE PARTITION PRIMARY command without the ID parameter to + create primary partitions on GPT disks. + + This command does not work on dynamic disks nor on Microsoft Reserved + partitions. + +Example: + SET ID=07 OVERRIDE + SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 . Language=Portugese -<Add SETID command help text here> + Changes the partition type field for the partition with focus. + +Syntax: SET ID={<BYTE> | <GUID>} [OVERRIDE] [NOERR] + + ID={<BYTE> | <GUID>} + + Specifies the new partition type. + For master boot record (MBR) disks, you can specify a partition + type byte, in hexadecimal form, for the partition. Any + partition type byte can be specified with this parameter except + for type 0x42 (LDM partition). Note that the leading '0x' is + omitted when specifying the hexadecimal partition type. + + For GUID partition table (GPT) disks you can specify a + partition type GUID for the partition. Recognized GUIDs + include: + + EFI System partition: + c12a7328-f81f-11d2-ba4b-00a0c93ec93b + + Basic data partition: + ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 + + Any partition type GUID can be specified with this parameter + except for the following: + + Microsoft Reserved partition: + e3c9e316-0b5c-4db8-817d-f92df00215a + + LDM Metadata partition on a dynamic disk: + 5808c8aa-7e8f-42e0-85d2-e1e90434cfb3 + + LDM Data partition on a dynamic disk: + af9b60a0-1431-4f62-bc68-3311714a69ad + + Cluster Metadata partition: + db97dba9-0840-4bae-97f0-ffb9a327c7e1 + + + Other than the limitations mentioned, DiskPart otherwise does + not check the partition type for validity except to ensure that + it is a byte in hexadecimal form or a GUID. + + OVERRIDE Enables DiskPart to force the file system on the volume to + dismount before changing the partition type. When changing + the partition type, DiskPart will attempt to lock and dismount + the file system on the volume. If this parameter is not specified, + and the call to lock the file system fails, (because some other + application has an open handle to the volume), the entire + operation will fail. When this parameter is specified, the + dismount is forced even if the call to lock the file system + fails. When a file system is dismounted, all opened handles to + the volume will become invalid. + + NOERR For scripting only. When an error is encountered, DiskPart + continues to process commands as if the error did not occur. + Without the NOERR parameter, an error causes DiskPart to exit + with an error code. + + Intended for Original Equipment Manufacturer (OEM) use only. + + A partition must be selected for this operation to succeed. + + Caution: + + Changing partition type fields with this parameter might cause your + computer to fail or be unable to start up. Unless you are an OEM or an + IT professional experienced with GPT disks, do not change partition + type fields on GPT disks using this parameter. Instead, always use the + CREATE PARTITION EFI command to create EFI System partitions, the + CREATE PARTITION MSR command to create Microsoft Reserved partitions, + and the CREATE PARTITION PRIMARY command without the ID parameter to + create primary partitions on GPT disks. + + This command does not work on dynamic disks nor on Microsoft Reserved + partitions. + +Example: + SET ID=07 OVERRIDE + SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 . Language=Romanian -<Add SETID command help text here> + Changes the partition type field for the partition with focus. + +Syntax: SET ID={<BYTE> | <GUID>} [OVERRIDE] [NOERR] + + ID={<BYTE> | <GUID>} + + Specifies the new partition type. + For master boot record (MBR) disks, you can specify a partition + type byte, in hexadecimal form, for the partition. Any + partition type byte can be specified with this parameter except + for type 0x42 (LDM partition). Note that the leading '0x' is + omitted when specifying the hexadecimal partition type. + + For GUID partition table (GPT) disks you can specify a + partition type GUID for the partition. Recognized GUIDs + include: + + EFI System partition: + c12a7328-f81f-11d2-ba4b-00a0c93ec93b + + Basic data partition: + ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 + + Any partition type GUID can be specified with this parameter + except for the following: + + Microsoft Reserved partition: + e3c9e316-0b5c-4db8-817d-f92df00215a + + LDM Metadata partition on a dynamic disk: + 5808c8aa-7e8f-42e0-85d2-e1e90434cfb3 + + LDM Data partition on a dynamic disk: + af9b60a0-1431-4f62-bc68-3311714a69ad + + Cluster Metadata partition: + db97dba9-0840-4bae-97f0-ffb9a327c7e1 + + + Other than the limitations mentioned, DiskPart otherwise does + not check the partition type for validity except to ensure that + it is a byte in hexadecimal form or a GUID. + + OVERRIDE Enables DiskPart to force the file system on the volume to + dismount before changing the partition type. When changing + the partition type, DiskPart will attempt to lock and dismount + the file system on the volume. If this parameter is not specified, + and the call to lock the file system fails, (because some other + application has an open handle to the volume), the entire + operation will fail. When this parameter is specified, the + dismount is forced even if the call to lock the file system + fails. When a file system is dismounted, all opened handles to + the volume will become invalid. + + NOERR For scripting only. When an error is encountered, DiskPart + continues to process commands as if the error did not occur. + Without the NOERR parameter, an error causes DiskPart to exit + with an error code. + + Intended for Original Equipment Manufacturer (OEM) use only. + + A partition must be selected for this operation to succeed. + + Caution: + + Changing partition type fields with this parameter might cause your + computer to fail or be unable to start up. Unless you are an OEM or an + IT professional experienced with GPT disks, do not change partition + type fields on GPT disks using this parameter. Instead, always use the + CREATE PARTITION EFI command to create EFI System partitions, the + CREATE PARTITION MSR command to create Microsoft Reserved partitions, + and the CREATE PARTITION PRIMARY command without the ID parameter to + create primary partitions on GPT disks. + + This command does not work on dynamic disks nor on Microsoft Reserved + partitions. + +Example: + SET ID=07 OVERRIDE + SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 . Language=Russian -<Add SETID command help text here> + Changes the partition type field for the partition with focus. + +Syntax: SET ID={<BYTE> | <GUID>} [OVERRIDE] [NOERR] + + ID={<BYTE> | <GUID>} + + Specifies the new partition type. + For master boot record (MBR) disks, you can specify a partition + type byte, in hexadecimal form, for the partition. Any + partition type byte can be specified with this parameter except + for type 0x42 (LDM partition). Note that the leading '0x' is + omitted when specifying the hexadecimal partition type. + + For GUID partition table (GPT) disks you can specify a + partition type GUID for the partition. Recognized GUIDs + include: + + EFI System partition: + c12a7328-f81f-11d2-ba4b-00a0c93ec93b + + Basic data partition: + ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 + + Any partition type GUID can be specified with this parameter + except for the following: + + Microsoft Reserved partition: + e3c9e316-0b5c-4db8-817d-f92df00215a + + LDM Metadata partition on a dynamic disk: + 5808c8aa-7e8f-42e0-85d2-e1e90434cfb3 + + LDM Data partition on a dynamic disk: + af9b60a0-1431-4f62-bc68-3311714a69ad + + Cluster Metadata partition: + db97dba9-0840-4bae-97f0-ffb9a327c7e1 + + + Other than the limitations mentioned, DiskPart otherwise does + not check the partition type for validity except to ensure that + it is a byte in hexadecimal form or a GUID. + + OVERRIDE Enables DiskPart to force the file system on the volume to + dismount before changing the partition type. When changing + the partition type, DiskPart will attempt to lock and dismount + the file system on the volume. If this parameter is not specified, + and the call to lock the file system fails, (because some other + application has an open handle to the volume), the entire + operation will fail. When this parameter is specified, the + dismount is forced even if the call to lock the file system + fails. When a file system is dismounted, all opened handles to + the volume will become invalid. + + NOERR For scripting only. When an error is encountered, DiskPart + continues to process commands as if the error did not occur. + Without the NOERR parameter, an error causes DiskPart to exit + with an error code. + + Intended for Original Equipment Manufacturer (OEM) use only. + + A partition must be selected for this operation to succeed. + + Caution: + + Changing partition type fields with this parameter might cause your + computer to fail or be unable to start up. Unless you are an OEM or an + IT professional experienced with GPT disks, do not change partition + type fields on GPT disks using this parameter. Instead, always use the + CREATE PARTITION EFI command to create EFI System partitions, the + CREATE PARTITION MSR command to create Microsoft Reserved partitions, + and the CREATE PARTITION PRIMARY command without the ID parameter to + create primary partitions on GPT disks. + + This command does not work on dynamic disks nor on Microsoft Reserved + partitions. + +Example: + SET ID=07 OVERRIDE + SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 . Language=Albanian -<Add SETID command help text here> + Changes the partition type field for the partition with focus. + +Syntax: SET ID={<BYTE> | <GUID>} [OVERRIDE] [NOERR] + + ID={<BYTE> | <GUID>} + + Specifies the new partition type. + For master boot record (MBR) disks, you can specify a partition + type byte, in hexadecimal form, for the partition. Any + partition type byte can be specified with this parameter except + for type 0x42 (LDM partition). Note that the leading '0x' is + omitted when specifying the hexadecimal partition type. + + For GUID partition table (GPT) disks you can specify a + partition type GUID for the partition. Recognized GUIDs + include: + + EFI System partition: + c12a7328-f81f-11d2-ba4b-00a0c93ec93b + + Basic data partition: + ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 + + Any partition type GUID can be specified with this parameter + except for the following: + + Microsoft Reserved partition: + e3c9e316-0b5c-4db8-817d-f92df00215a + + LDM Metadata partition on a dynamic disk: + 5808c8aa-7e8f-42e0-85d2-e1e90434cfb3 + + LDM Data partition on a dynamic disk: + af9b60a0-1431-4f62-bc68-3311714a69ad + + Cluster Metadata partition: + db97dba9-0840-4bae-97f0-ffb9a327c7e1 + + + Other than the limitations mentioned, DiskPart otherwise does + not check the partition type for validity except to ensure that + it is a byte in hexadecimal form or a GUID. + + OVERRIDE Enables DiskPart to force the file system on the volume to + dismount before changing the partition type. When changing + the partition type, DiskPart will attempt to lock and dismount + the file system on the volume. If this parameter is not specified, + and the call to lock the file system fails, (because some other + application has an open handle to the volume), the entire + operation will fail. When this parameter is specified, the + dismount is forced even if the call to lock the file system + fails. When a file system is dismounted, all opened handles to + the volume will become invalid. + + NOERR For scripting only. When an error is encountered, DiskPart + continues to process commands as if the error did not occur. + Without the NOERR parameter, an error causes DiskPart to exit + with an error code. + + Intended for Original Equipment Manufacturer (OEM) use only. + + A partition must be selected for this operation to succeed. + + Caution: + + Changing partition type fields with this parameter might cause your + computer to fail or be unable to start up. Unless you are an OEM or an + IT professional experienced with GPT disks, do not change partition + type fields on GPT disks using this parameter. Instead, always use the + CREATE PARTITION EFI command to create EFI System partitions, the + CREATE PARTITION MSR command to create Microsoft Reserved partitions, + and the CREATE PARTITION PRIMARY command without the ID parameter to + create primary partitions on GPT disks. + + This command does not work on dynamic disks nor on Microsoft Reserved + partitions. + +Example: + SET ID=07 OVERRIDE + SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 . Language=Turkish -<Add SETID command help text here> + Changes the partition type field for the partition with focus. + +Syntax: SET ID={<BYTE> | <GUID>} [OVERRIDE] [NOERR] + + ID={<BYTE> | <GUID>} + + Specifies the new partition type. + For master boot record (MBR) disks, you can specify a partition + type byte, in hexadecimal form, for the partition. Any + partition type byte can be specified with this parameter except + for type 0x42 (LDM partition). Note that the leading '0x' is + omitted when specifying the hexadecimal partition type. + + For GUID partition table (GPT) disks you can specify a + partition type GUID for the partition. Recognized GUIDs + include: + + EFI System partition: + c12a7328-f81f-11d2-ba4b-00a0c93ec93b + + Basic data partition: + ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 + + Any partition type GUID can be specified with this parameter + except for the following: + + Microsoft Reserved partition: + e3c9e316-0b5c-4db8-817d-f92df00215a + + LDM Metadata partition on a dynamic disk: + 5808c8aa-7e8f-42e0-85d2-e1e90434cfb3 + + LDM Data partition on a dynamic disk: + af9b60a0-1431-4f62-bc68-3311714a69ad + + Cluster Metadata partition: + db97dba9-0840-4bae-97f0-ffb9a327c7e1 + + + Other than the limitations mentioned, DiskPart otherwise does + not check the partition type for validity except to ensure that + it is a byte in hexadecimal form or a GUID. + + OVERRIDE Enables DiskPart to force the file system on the volume to + dismount before changing the partition type. When changing + the partition type, DiskPart will attempt to lock and dismount + the file system on the volume. If this parameter is not specified, + and the call to lock the file system fails, (because some other + application has an open handle to the volume), the entire + operation will fail. When this parameter is specified, the + dismount is forced even if the call to lock the file system + fails. When a file system is dismounted, all opened handles to + the volume will become invalid. + + NOERR For scripting only. When an error is encountered, DiskPart + continues to process commands as if the error did not occur. + Without the NOERR parameter, an error causes DiskPart to exit + with an error code. + + Intended for Original Equipment Manufacturer (OEM) use only. + + A partition must be selected for this operation to succeed. + + Caution: + + Changing partition type fields with this parameter might cause your + computer to fail or be unable to start up. Unless you are an OEM or an + IT professional experienced with GPT disks, do not change partition + type fields on GPT disks using this parameter. Instead, always use the + CREATE PARTITION EFI command to create EFI System partitions, the + CREATE PARTITION MSR command to create Microsoft Reserved partitions, + and the CREATE PARTITION PRIMARY command without the ID parameter to + create primary partitions on GPT disks. + + This command does not work on dynamic disks nor on Microsoft Reserved + partitions. + +Example: + SET ID=07 OVERRIDE + SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 . Language=Chinese -<Add SETID command help text here> + Changes the partition type field for the partition with focus. + +Syntax: SET ID={<BYTE> | <GUID>} [OVERRIDE] [NOERR] + + ID={<BYTE> | <GUID>} + + Specifies the new partition type. + For master boot record (MBR) disks, you can specify a partition + type byte, in hexadecimal form, for the partition. Any + partition type byte can be specified with this parameter except + for type 0x42 (LDM partition). Note that the leading '0x' is + omitted when specifying the hexadecimal partition type. + + For GUID partition table (GPT) disks you can specify a + partition type GUID for the partition. Recognized GUIDs + include: + + EFI System partition: + c12a7328-f81f-11d2-ba4b-00a0c93ec93b + + Basic data partition: + ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 + + Any partition type GUID can be specified with this parameter + except for the following: + + Microsoft Reserved partition: + e3c9e316-0b5c-4db8-817d-f92df00215a + + LDM Metadata partition on a dynamic disk: + 5808c8aa-7e8f-42e0-85d2-e1e90434cfb3 + + LDM Data partition on a dynamic disk: + af9b60a0-1431-4f62-bc68-3311714a69ad + + Cluster Metadata partition: + db97dba9-0840-4bae-97f0-ffb9a327c7e1 + + + Other than the limitations mentioned, DiskPart otherwise does + not check the partition type for validity except to ensure that + it is a byte in hexadecimal form or a GUID. + + OVERRIDE Enables DiskPart to force the file system on the volume to + dismount before changing the partition type. When changing + the partition type, DiskPart will attempt to lock and dismount + the file system on the volume. If this parameter is not specified, + and the call to lock the file system fails, (because some other + application has an open handle to the volume), the entire + operation will fail. When this parameter is specified, the + dismount is forced even if the call to lock the file system + fails. When a file system is dismounted, all opened handles to + the volume will become invalid. + + NOERR For scripting only. When an error is encountered, DiskPart + continues to process commands as if the error did not occur. + Without the NOERR parameter, an error causes DiskPart to exit + with an error code. + + Intended for Original Equipment Manufacturer (OEM) use only. + + A partition must be selected for this operation to succeed. + + Caution: + + Changing partition type fields with this parameter might cause your + computer to fail or be unable to start up. Unless you are an OEM or an + IT professional experienced with GPT disks, do not change partition + type fields on GPT disks using this parameter. Instead, always use the + CREATE PARTITION EFI command to create EFI System partitions, the + CREATE PARTITION MSR command to create Microsoft Reserved partitions, + and the CREATE PARTITION PRIMARY command without the ID parameter to + create primary partitions on GPT disks. + + This command does not work on dynamic disks nor on Microsoft Reserved + partitions. + +Example: + SET ID=07 OVERRIDE + SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 . Language=Taiwanese -<Add SETID command help text here> + Changes the partition type field for the partition with focus. + +Syntax: SET ID={<BYTE> | <GUID>} [OVERRIDE] [NOERR] + + ID={<BYTE> | <GUID>} + + Specifies the new partition type. + For master boot record (MBR) disks, you can specify a partition + type byte, in hexadecimal form, for the partition. Any + partition type byte can be specified with this parameter except + for type 0x42 (LDM partition). Note that the leading '0x' is + omitted when specifying the hexadecimal partition type. + + For GUID partition table (GPT) disks you can specify a + partition type GUID for the partition. Recognized GUIDs + include: + + EFI System partition: + c12a7328-f81f-11d2-ba4b-00a0c93ec93b + + Basic data partition: + ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 + + Any partition type GUID can be specified with this parameter + except for the following: + + Microsoft Reserved partition: + e3c9e316-0b5c-4db8-817d-f92df00215a + + LDM Metadata partition on a dynamic disk: + 5808c8aa-7e8f-42e0-85d2-e1e90434cfb3 + + LDM Data partition on a dynamic disk: + af9b60a0-1431-4f62-bc68-3311714a69ad + + Cluster Metadata partition: + db97dba9-0840-4bae-97f0-ffb9a327c7e1 + + + Other than the limitations mentioned, DiskPart otherwise does + not check the partition type for validity except to ensure that + it is a byte in hexadecimal form or a GUID. + + OVERRIDE Enables DiskPart to force the file system on the volume to + dismount before changing the partition type. When changing + the partition type, DiskPart will attempt to lock and dismount + the file system on the volume. If this parameter is not specified, + and the call to lock the file system fails, (because some other + application has an open handle to the volume), the entire + operation will fail. When this parameter is specified, the + dismount is forced even if the call to lock the file system + fails. When a file system is dismounted, all opened handles to + the volume will become invalid. + + NOERR For scripting only. When an error is encountered, DiskPart + continues to process commands as if the error did not occur. + Without the NOERR parameter, an error causes DiskPart to exit + with an error code. + + Intended for Original Equipment Manufacturer (OEM) use only. + + A partition must be selected for this operation to succeed. + + Caution: + + Changing partition type fields with this parameter might cause your + computer to fail or be unable to start up. Unless you are an OEM or an + IT professional experienced with GPT disks, do not change partition + type fields on GPT disks using this parameter. Instead, always use the + CREATE PARTITION EFI command to create EFI System partitions, the + CREATE PARTITION MSR command to create Microsoft Reserved partitions, + and the CREATE PARTITION PRIMARY command without the ID parameter to + create primary partitions on GPT disks. + + This command does not work on dynamic disks nor on Microsoft Reserved + partitions. + +Example: + SET ID=07 OVERRIDE + SET ID=ebd0a0a2-b9e5-4433-87c0-68b6b72699c7 .

1 0

[reactos] 01/01: [NTDLL_APITEST] Write tests for NtQueryInformationToken and NtSetInformationToken
by George Bișoc 10 Jun '22

10 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=bac1bce60549b0a1e5dc5… commit bac1bce60549b0a1e5dc5b77c53ea9d2cc1e430e Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sun Jun 5 23:24:06 2022 +0200 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Thu Jun 9 19:20:31 2022 +0200 [NTDLL_APITEST] Write tests for NtQueryInformationToken and NtSetInformationToken --- modules/rostests/apitests/ntdll/CMakeLists.txt | 2 + .../apitests/ntdll/NtQueryInformationToken.c | 699 +++++++++++++++++++++ .../apitests/ntdll/NtSetInformationToken.c | 247 ++++++++ modules/rostests/apitests/ntdll/testlist.c | 4 + 4 files changed, 952 insertions(+) diff --git a/modules/rostests/apitests/ntdll/CMakeLists.txt b/modules/rostests/apitests/ntdll/CMakeLists.txt index a50b1898a76..39296e4d8f2 100644 --- a/modules/rostests/apitests/ntdll/CMakeLists.txt +++ b/modules/rostests/apitests/ntdll/CMakeLists.txt @@ -35,6 +35,7 @@ list(APPEND SOURCE NtQueryInformationFile.c NtQueryInformationProcess.c NtQueryInformationThread.c + NtQueryInformationToken.c NtQueryKey.c NtQuerySystemEnvironmentValue.c NtQuerySystemInformation.c @@ -45,6 +46,7 @@ list(APPEND SOURCE NtSetInformationFile.c NtSetInformationProcess.c NtSetInformationThread.c + NtSetInformationToken.c NtSetValueKey.c NtSetVolumeInformationFile.c NtUnloadDriver.c diff --git a/modules/rostests/apitests/ntdll/NtQueryInformationToken.c b/modules/rostests/apitests/ntdll/NtQueryInformationToken.c new file mode 100644 index 00000000000..18e8001f99b --- /dev/null +++ b/modules/rostests/apitests/ntdll/NtQueryInformationToken.c @@ -0,0 +1,699 @@ +/* + * PROJECT: ReactOS API tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Tests for the NtQueryInformationToken API + * COPYRIGHT: Copyright 2022 George Bișoc <george.bisoc(a)reactos.org> + */ + +#include "precomp.h" + +static +HANDLE +OpenCurrentToken(VOID) +{ + BOOL Success; + HANDLE Token; + + Success = OpenProcessToken(GetCurrentProcess(), + TOKEN_READ | TOKEN_QUERY_SOURCE | TOKEN_DUPLICATE, + &Token); + if (!Success) + { + ok(0, "OpenProcessToken() has failed to get the process' token (error code: %lu)!\n", GetLastError()); + return NULL; + } + + return Token; +} + +static +VOID +QueryTokenUserTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PTOKEN_USER UserToken; + ULONG BufferLength; + UNICODE_STRING SidString; + + /* + * Query the exact buffer length to hold + * our stuff, STATUS_BUFFER_TOO_SMALL must + * be expected here. + */ + Status = NtQueryInformationToken(Token, + TokenUser, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + /* Allocate the buffer based on the size we got */ + UserToken = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!UserToken) + { + ok(0, "Failed to allocate from heap for token user (required buffer length %lu)!\n", BufferLength); + return; + } + + /* Now do the actual query */ + Status = NtQueryInformationToken(Token, + TokenUser, + UserToken, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + + RtlConvertSidToUnicodeString(&SidString, UserToken->User.Sid, TRUE); + trace("=============== TokenUser ===============\n"); + trace("The SID of current token user is: %s\n", wine_dbgstr_w(SidString.Buffer)); + trace("=========================================\n\n"); + RtlFreeUnicodeString(&SidString); + + RtlFreeHeap(RtlGetProcessHeap(), 0, UserToken); +} + +static +VOID +QueryTokenGroupsTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PTOKEN_GROUPS Groups; + ULONG BufferLength; + + /* + * Query the exact buffer length to hold + * our stuff, STATUS_BUFFER_TOO_SMALL must + * be expected here. + */ + Status = NtQueryInformationToken(Token, + TokenGroups, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + /* Allocate the buffer based on the size we got */ + Groups = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!Groups) + { + ok(0, "Failed to allocate from heap for token groups (required buffer length %lu)!\n", BufferLength); + return; + } + + /* + * Now do the actual query and validate the + * number of groups. + */ + Status = NtQueryInformationToken(Token, + TokenGroups, + Groups, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + ok(Groups->GroupCount == 10, "The number of groups must be 10 (current number %lu)!\n", Groups->GroupCount); + + RtlFreeHeap(RtlGetProcessHeap(), 0, Groups); +} + +static +VOID +QueryTokenPrivilegesTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PTOKEN_PRIVILEGES Privileges; + ULONG BufferLength; + + /* + * Query the exact buffer length to hold + * our stuff, STATUS_BUFFER_TOO_SMALL must + * be expected here. + */ + Status = NtQueryInformationToken(Token, + TokenPrivileges, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + /* Allocate the buffer based on the size we got */ + Privileges = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!Privileges) + { + ok(0, "Failed to allocate from heap for token privileges (required buffer length %lu)!\n", BufferLength); + return; + } + + /* + * Now do the actual query and validate the + * number of privileges. + */ + Status = NtQueryInformationToken(Token, + TokenPrivileges, + Privileges, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + ok(Privileges->PrivilegeCount == 20, "The number of privileges must be 20 (current number %lu)!\n", Privileges->PrivilegeCount); + + RtlFreeHeap(RtlGetProcessHeap(), 0, Privileges); +} + +static +VOID +QueryTokenOwnerTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PTOKEN_OWNER Owner; + ULONG BufferLength; + UNICODE_STRING SidString; + + /* + * Query the exact buffer length to hold + * our stuff, STATUS_BUFFER_TOO_SMALL must + * be expected here. + */ + Status = NtQueryInformationToken(Token, + TokenOwner, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + /* Allocate the buffer based on the size we got */ + Owner = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!Owner) + { + ok(0, "Failed to allocate from heap for token owner (required buffer length %lu)!\n", BufferLength); + return; + } + + /* + * Now do the actual query and validate the + * token owner (must be the local admin). + */ + Status = NtQueryInformationToken(Token, + TokenOwner, + Owner, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + + RtlConvertSidToUnicodeString(&SidString, Owner->Owner, TRUE); + ok_wstr(SidString.Buffer, L"S-1-5-32-544"); + RtlFreeUnicodeString(&SidString); + + RtlFreeHeap(RtlGetProcessHeap(), 0, Owner); +} + +static +VOID +QueryTokenPrimaryGroupTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PTOKEN_PRIMARY_GROUP PrimaryGroup; + ULONG BufferLength; + UNICODE_STRING SidString; + + /* + * Query the exact buffer length to hold + * our stuff, STATUS_BUFFER_TOO_SMALL must + * be expected here. + */ + Status = NtQueryInformationToken(Token, + TokenPrimaryGroup, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + /* Allocate the buffer based on the size we got */ + PrimaryGroup = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!PrimaryGroup) + { + ok(0, "Failed to allocate from heap for token primary group (required buffer length %lu)!\n", BufferLength); + return; + } + + /* Now do the actual query */ + Status = NtQueryInformationToken(Token, + TokenPrimaryGroup, + PrimaryGroup, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + + RtlConvertSidToUnicodeString(&SidString, PrimaryGroup->PrimaryGroup, TRUE); + trace("=============== TokenPrimaryGroup ===============\n"); + trace("The primary group SID of current token is: %s\n", wine_dbgstr_w(SidString.Buffer)); + trace("=========================================\n\n"); + RtlFreeUnicodeString(&SidString); + + RtlFreeHeap(RtlGetProcessHeap(), 0, PrimaryGroup); +} + +static +VOID +QueryTokenDefaultDaclTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PTOKEN_DEFAULT_DACL Dacl; + ULONG BufferLength; + + /* + * Query the exact buffer length to hold + * our stuff, STATUS_BUFFER_TOO_SMALL must + * be expected here. + */ + Status = NtQueryInformationToken(Token, + TokenDefaultDacl, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + /* Allocate the buffer based on the size we got */ + Dacl = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!Dacl) + { + ok(0, "Failed to allocate from heap for token default DACL (required buffer length %lu)!\n", BufferLength); + return; + } + + /* + * Now do the actual query and validate the + * ACL revision and number count of ACEs. + */ + Status = NtQueryInformationToken(Token, + TokenDefaultDacl, + Dacl, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + ok(Dacl->DefaultDacl->AclRevision == 2, "The ACL revision of token default DACL must be 2 (current revision %u)!\n", Dacl->DefaultDacl->AclRevision); + ok(Dacl->DefaultDacl->AceCount == 2, "The ACL's ACE count must be 2 (current ACE count %u)!\n", Dacl->DefaultDacl->AceCount); + + RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl); +} + +static +VOID +QueryTokenSourceTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PTOKEN_SOURCE Source; + ULONG BufferLength; + CHAR SourceName[8]; + + /* + * Query the exact buffer length to hold + * our stuff, STATUS_BUFFER_TOO_SMALL must + * be expected here. + */ + Status = NtQueryInformationToken(Token, + TokenSource, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + /* Allocate the buffer based on the size we got */ + Source = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!Source) + { + ok(0, "Failed to allocate from heap for token source (required buffer length %lu)!\n", BufferLength); + return; + } + + /* Now do the actual query */ + Status = NtQueryInformationToken(Token, + TokenSource, + Source, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + + /* + * Subtract the source name from the queried buffer + * and compare it. The source name in question must be + * "User32" as the primary token of the current calling + * process is generated when the user has successfully + * logged in and he's into the desktop. + */ + SourceName[0] = Source->SourceName[0]; + SourceName[1] = Source->SourceName[1]; + SourceName[2] = Source->SourceName[2]; + SourceName[3] = Source->SourceName[3]; + SourceName[4] = Source->SourceName[4]; + SourceName[5] = Source->SourceName[5]; + SourceName[6] = '\0'; + ok_str(SourceName, "User32"); + + RtlFreeHeap(RtlGetProcessHeap(), 0, Source); +} + +static +VOID +QueryTokenTypeTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + TOKEN_TYPE Type; + ULONG BufferLength; + + /* + * Query the token type. The token of the + * current calling process must be primary + * since we aren't impersonating the security + * context of a client. + */ + Status = NtQueryInformationToken(Token, + TokenType, + &Type, + sizeof(TOKEN_TYPE), + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + ok(Type == TokenPrimary, "The current token is not primary!\n"); +} + +static +VOID +QueryTokenImpersonationTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + SECURITY_IMPERSONATION_LEVEL Level; + ULONG BufferLength; + HANDLE DupToken; + OBJECT_ATTRIBUTES ObjectAttributes; + + /* + * Windows throws STATUS_INVALID_INFO_CLASS here + * because one cannot simply query the impersonation + * level of a primary token. + */ + Status = NtQueryInformationToken(Token, + TokenImpersonationLevel, + &Level, + sizeof(SECURITY_IMPERSONATION_LEVEL), + &BufferLength); + ok_ntstatus(Status, STATUS_INVALID_INFO_CLASS); + + /* + * Initialize the object attribute and duplicate + * the token into an actual impersonation one. + */ + InitializeObjectAttributes(&ObjectAttributes, + NULL, + 0, + NULL, + NULL); + + Status = NtDuplicateToken(Token, + TOKEN_QUERY, + &ObjectAttributes, + FALSE, + TokenImpersonation, + &DupToken); + if (!NT_SUCCESS(Status)) + { + ok(0, "Failed to duplicate token (Status code %lx)!\n", Status); + return; + } + + /* Now do the actual query */ + Status = NtQueryInformationToken(DupToken, + TokenImpersonationLevel, + &Level, + sizeof(SECURITY_IMPERSONATION_LEVEL), + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + ok(Level == SecurityAnonymous, "The current token impersonation level is not anonymous!\n"); + CloseHandle(DupToken); +} + +static +VOID +QueryTokenStatisticsTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PTOKEN_STATISTICS Statistics; + ULONG BufferLength; + + /* + * Query the exact buffer length to hold + * our stuff, STATUS_BUFFER_TOO_SMALL must + * be expected here. + */ + Status = NtQueryInformationToken(Token, + TokenStatistics, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + /* Allocate the buffer based on the size we got */ + Statistics = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!Statistics) + { + skip("Failed to allocate heap for token statistics!\n"); + return; + } + + /* Do the actual query */ + Status = NtQueryInformationToken(Token, + TokenStatistics, + Statistics, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + + trace("=============== TokenStatistics ===============\n"); + trace("Token ID: %lu %lu\n", Statistics->TokenId.LowPart, Statistics->TokenId.HighPart); + trace("Authentication ID: %lu %lu\n", Statistics->AuthenticationId.LowPart, Statistics->AuthenticationId.HighPart); + trace("Dynamic Charged: %lu\n", Statistics->DynamicCharged); + trace("Dynamic Available: %lu\n", Statistics->DynamicAvailable); + trace("Modified ID: %lu %lu\n", Statistics->ModifiedId.LowPart, Statistics->ModifiedId.HighPart); + trace("=========================================\n\n"); + + RtlFreeHeap(RtlGetProcessHeap(), 0, Statistics); +} + +static +VOID +QueryTokenRestrictedSidsTest( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PTOKEN_GROUPS RestrictedGroups; + TOKEN_GROUPS SidToRestrict; + ULONG BufferLength; + HANDLE FilteredToken; + PSID WorldSid; + static SID_IDENTIFIER_AUTHORITY WorldAuthority = {SECURITY_WORLD_SID_AUTHORITY}; + + /* + * Query the exact buffer length to hold + * our stuff, STATUS_BUFFER_TOO_SMALL must + * be expected here. + */ + Status = NtQueryInformationToken(Token, + TokenRestrictedSids, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + /* Allocate the buffer based on the size we got */ + RestrictedGroups = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!RestrictedGroups) + { + ok(0, "Failed to allocate from heap for restricted SIDs (required buffer length %lu)!\n", BufferLength); + return; + } + + /* + * Query the number of restricted SIDs. Originally the token + * doesn't have any restricted SIDs inserted. + */ + Status = NtQueryInformationToken(Token, + TokenRestrictedSids, + RestrictedGroups, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + ok(RestrictedGroups->GroupCount == 0, "There mustn't be any restricted SIDs before filtering (number of restricted SIDs %lu)!\n", RestrictedGroups->GroupCount); + + RtlFreeHeap(RtlGetProcessHeap(), 0, RestrictedGroups); + RestrictedGroups = NULL; + + Status = RtlAllocateAndInitializeSid(&WorldAuthority, + 1, + SECURITY_WORLD_RID, + 0, 0, 0, 0, 0, 0, 0, + &WorldSid); + if (!NT_SUCCESS(Status)) + { + ok(0, "Failed to allocate World SID (Status code %lx)!\n", Status); + return; + } + + SidToRestrict.GroupCount = 1; + SidToRestrict.Groups[0].Attributes = 0; + SidToRestrict.Groups[0].Sid = WorldSid; + + Status = NtFilterToken(Token, + 0, + NULL, + NULL, + &SidToRestrict, + &FilteredToken); + if (!NT_SUCCESS(Status)) + { + ok(0, "Failed to filter the current token (Status code %lx)!\n", Status); + RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid); + return; + } + + Status = NtQueryInformationToken(FilteredToken, + TokenRestrictedSids, + NULL, + 0, + &BufferLength); + ok_ntstatus(Status, STATUS_BUFFER_TOO_SMALL); + + RestrictedGroups = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!RestrictedGroups) + { + ok(0, "Failed to allocate from heap for restricted SIDs (required buffer length %lu)!\n", BufferLength); + RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid); + return; + } + + /* + * Do a query again, this time we must have a + * restricted SID inserted into the token. + */ + Status = NtQueryInformationToken(FilteredToken, + TokenRestrictedSids, + RestrictedGroups, + BufferLength, + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + ok(RestrictedGroups->GroupCount == 1, "There must be only one restricted SID added in token (number of restricted SIDs %lu)!\n", RestrictedGroups->GroupCount); + + RtlFreeHeap(RtlGetProcessHeap(), 0, RestrictedGroups); + RtlFreeHeap(RtlGetProcessHeap(), 0, WorldSid); + CloseHandle(FilteredToken); +} + +static +VOID +QueryTokenSessionIdTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + ULONG SessionId; + ULONG BufferLength; + + /* + * Query the session ID. Generally the current + * process token is not under any terminal service + * so the ID must be 0. + */ + Status = NtQueryInformationToken(Token, + TokenSessionId, + &SessionId, + sizeof(ULONG), + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + ok(SessionId == 0, "The session ID of current token must be 0 (current session %lu)!\n", SessionId); +} + +static +VOID +QueryTokenOriginTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + TOKEN_ORIGIN Origin; + ULONG BufferLength; + + /* Query the token origin */ + Status = NtQueryInformationToken(Token, + TokenOrigin, + &Origin, + sizeof(TOKEN_ORIGIN), + &BufferLength); + ok_ntstatus(Status, STATUS_SUCCESS); + ok(Origin.OriginatingLogonSession.LowPart == 0x3e7, "The LowPart field of the originating logon session must be SYSTEM_LUID (current value %lu)!\n", + Origin.OriginatingLogonSession.LowPart); + ok(Origin.OriginatingLogonSession.HighPart == 0x0, "The HighPart field of the logon session must be 0 (current value %lu)!\n", + Origin.OriginatingLogonSession.HighPart); +} + +START_TEST(NtQueryInformationToken) +{ + NTSTATUS Status; + HANDLE Token; + PVOID Dummy; + ULONG DummyReturnLength; + + /* ReturnLength is NULL */ + Status = NtQueryInformationToken(NULL, + TokenUser, + NULL, + 0, + NULL); + ok_ntstatus(Status, STATUS_ACCESS_VIOLATION); + + /* We don't give any token here */ + Status = NtQueryInformationToken(NULL, + TokenUser, + &Dummy, + 0, + &DummyReturnLength); + ok_ntstatus(Status, STATUS_INVALID_HANDLE); + + Token = OpenCurrentToken(); + + /* Class 0 is unused on Windows */ + Status = NtQueryInformationToken(Token, + 0, + &Dummy, + 0, + &DummyReturnLength); + ok_ntstatus(Status, STATUS_INVALID_INFO_CLASS); + + /* We give a bogus info class */ + Status = NtQueryInformationToken(Token, + 0xa0a, + &Dummy, + 0, + &DummyReturnLength); + ok_ntstatus(Status, STATUS_INVALID_INFO_CLASS); + + /* Now perform tests for each class */ + QueryTokenUserTests(Token); + QueryTokenGroupsTests(Token); + QueryTokenPrivilegesTests(Token); + QueryTokenOwnerTests(Token); + QueryTokenPrimaryGroupTests(Token); + QueryTokenDefaultDaclTests(Token); + QueryTokenSourceTests(Token); + QueryTokenTypeTests(Token); + QueryTokenImpersonationTests(Token); + QueryTokenStatisticsTests(Token); + QueryTokenRestrictedSidsTest(Token); + QueryTokenSessionIdTests(Token); + QueryTokenOriginTests(Token); + + CloseHandle(Token); +} diff --git a/modules/rostests/apitests/ntdll/NtSetInformationToken.c b/modules/rostests/apitests/ntdll/NtSetInformationToken.c new file mode 100644 index 00000000000..cd51189345b --- /dev/null +++ b/modules/rostests/apitests/ntdll/NtSetInformationToken.c @@ -0,0 +1,247 @@ +/* + * PROJECT: ReactOS API tests + * LICENSE: GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later) + * PURPOSE: Tests for the NtSetInformationToken API + * COPYRIGHT: Copyright 2022 George Bișoc <george.bisoc(a)reactos.org> + */ + +#include "precomp.h" + +static +HANDLE +OpenCurrentToken(VOID) +{ + BOOL Success; + HANDLE Token; + + Success = OpenProcessToken(GetCurrentProcess(), + TOKEN_READ | TOKEN_ADJUST_DEFAULT | TOKEN_ADJUST_SESSIONID, + &Token); + if (!Success) + { + ok(0, "OpenProcessToken() has failed to get the process' token (error code: %lu)!\n", GetLastError()); + return NULL; + } + + return Token; +} + +static +PTOKEN_DEFAULT_DACL +QueryOriginalDefaultDacl( + _In_ HANDLE Token, + _Out_ PULONG DaclLength) +{ + NTSTATUS Status; + PTOKEN_DEFAULT_DACL Dacl; + ULONG BufferLength; + + *DaclLength = 0; + + Status = NtQueryInformationToken(Token, + TokenDefaultDacl, + NULL, + 0, + &BufferLength); + if (!NT_SUCCESS(Status) && (Status != STATUS_BUFFER_TOO_SMALL)) + { + ok(0, "Failed to query buffer length, STATUS_BUFFER_TOO_SMALL has to be expected (Status code %lx)!\n", Status); + return NULL; + } + + Dacl = RtlAllocateHeap(RtlGetProcessHeap(), 0, BufferLength); + if (!Dacl) + { + ok(0, "Failed to allocate from heap for token default DACL (required buffer length %lu)!\n", BufferLength); + return NULL; + } + + Status = NtQueryInformationToken(Token, + TokenDefaultDacl, + Dacl, + BufferLength, + &BufferLength); + if (!NT_SUCCESS(Status)) + { + ok(0, "Failed to query default DACL (Status code %lx)!\n", Status); + RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl); + return NULL; + } + + *DaclLength = BufferLength; + return Dacl; +} + +static +PACL +CreateNewDefaultDacl( + _Out_ PULONG DaclLength) +{ + NTSTATUS Status; + PACL Dacl; + ULONG Length; + PSID LocalSystemSid; + static SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY}; + + *DaclLength = 0; + + Status = RtlAllocateAndInitializeSid(&NtAuthority, + 1, + SECURITY_LOCAL_SYSTEM_RID, + 0, 0, 0, 0, 0, 0, 0, + &LocalSystemSid); + if (!NT_SUCCESS(Status)) + { + ok(0, "Failed to allocate Local System SID (Status code %lx)!\n", Status); + return NULL; + } + + Length = sizeof(ACL) + + sizeof(ACCESS_ALLOWED_ACE) + RtlLengthSid(LocalSystemSid); + + Dacl = RtlAllocateHeap(RtlGetProcessHeap(), + HEAP_ZERO_MEMORY, + Length); + if (!Dacl) + { + ok(0, "Failed to allocate from heap for DACL!\n"); + RtlFreeHeap(RtlGetProcessHeap(), 0, LocalSystemSid); + return NULL; + } + + Status = RtlCreateAcl(Dacl, + Length, + ACL_REVISION); + if (!NT_SUCCESS(Status)) + { + ok(0, "Failed to create ACL (Status code %lx)!\n", Status); + RtlFreeHeap(RtlGetProcessHeap(), 0, LocalSystemSid); + RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl); + return NULL; + } + + Status = RtlAddAccessAllowedAce(Dacl, + ACL_REVISION, + GENERIC_ALL, + LocalSystemSid); + if (!NT_SUCCESS(Status)) + { + ok(0, "Failed to add access allowed ACE (Status code %lx)!\n", Status); + RtlFreeHeap(RtlGetProcessHeap(), 0, LocalSystemSid); + RtlFreeHeap(RtlGetProcessHeap(), 0, Dacl); + return NULL; + } + + *DaclLength = Length; + RtlFreeHeap(RtlGetProcessHeap(), 0, LocalSystemSid); + return Dacl; +} + +static +VOID +SetTokenDefaultDaclTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + PACL NewDacl; + TOKEN_DEFAULT_DACL NewDefaultDacl; + PTOKEN_DEFAULT_DACL DefaultDacl; + ULONG OriginalDaclLength, NewDaclLength; + + /* + * Query the original DACL of the token first, + * we don't want to leave the token tampered + * later on. + */ + DefaultDacl = QueryOriginalDefaultDacl(Token, &OriginalDaclLength); + if (!DefaultDacl) + { + ok(0, "Failed to query token's default DACL!\n"); + return; + } + + /* Allocate new DACL */ + NewDacl = CreateNewDefaultDacl(&NewDaclLength); + if (!DefaultDacl) + { + ok(0, "Failed to allocate buffer for new DACL!\n"); + RtlFreeHeap(RtlGetProcessHeap(), 0, DefaultDacl); + return; + } + + NewDefaultDacl.DefaultDacl = NewDacl; + + /* + * Set a new DACL for the token. + */ + Status = NtSetInformationToken(Token, + TokenDefaultDacl, + &NewDefaultDacl, + NewDaclLength); + ok_ntstatus(Status, STATUS_SUCCESS); + + /* Now set the original DACL */ + Status = NtSetInformationToken(Token, + TokenDefaultDacl, + DefaultDacl, + OriginalDaclLength); + ok_ntstatus(Status, STATUS_SUCCESS); + + RtlFreeHeap(RtlGetProcessHeap(), 0, DefaultDacl); + RtlFreeHeap(RtlGetProcessHeap(), 0, NewDacl); +} + +static +VOID +SetTokenSessionIdTests( + _In_ HANDLE Token) +{ + NTSTATUS Status; + ULONG SessionId = 1; + + /* + * We're not allowed to set a session ID + * because we don't have the TCB privilege. + */ + Status = NtSetInformationToken(Token, + TokenSessionId, + &SessionId, + sizeof(ULONG)); + ok_ntstatus(Status, STATUS_PRIVILEGE_NOT_HELD); +} + +START_TEST(NtSetInformationToken) +{ + NTSTATUS Status; + ULONG DummyReturnLength = 0; + HANDLE Token; + + /* Everything else is NULL */ + Status = NtSetInformationToken(NULL, + TokenOwner, + NULL, + 0); + ok_ntstatus(Status, STATUS_INVALID_HANDLE); + + /* We don't give a token */ + Status = NtSetInformationToken(NULL, + TokenOwner, + NULL, + DummyReturnLength); + ok_ntstatus(Status, STATUS_INVALID_HANDLE); + + Token = OpenCurrentToken(); + + /* We give a bogus token class */ + Status = NtSetInformationToken(Token, + 0xa0a, + NULL, + DummyReturnLength); + ok_ntstatus(Status, STATUS_INVALID_INFO_CLASS); + + /* Now perform tests for each class */ + SetTokenDefaultDaclTests(Token); + SetTokenSessionIdTests(Token); + + CloseHandle(Token); +} diff --git a/modules/rostests/apitests/ntdll/testlist.c b/modules/rostests/apitests/ntdll/testlist.c index aff61fa3091..3b88411cfb6 100644 --- a/modules/rostests/apitests/ntdll/testlist.c +++ b/modules/rostests/apitests/ntdll/testlist.c @@ -31,6 +31,7 @@ extern void func_NtProtectVirtualMemory(void); extern void func_NtQueryInformationFile(void); extern void func_NtQueryInformationProcess(void); extern void func_NtQueryInformationThread(void); +extern void func_NtQueryInformationToken(void); extern void func_NtQueryKey(void); extern void func_NtQuerySystemEnvironmentValue(void); extern void func_NtQuerySystemInformation(void); @@ -41,6 +42,7 @@ extern void func_NtSaveKey(void); extern void func_NtSetInformationFile(void); extern void func_NtSetInformationProcess(void); extern void func_NtSetInformationThread(void); +extern void func_NtSetInformationToken(void); extern void func_NtSetValueKey(void); extern void func_NtSetVolumeInformationFile(void); extern void func_NtSystemInformation(void); @@ -119,6 +121,7 @@ const struct test winetest_testlist[] = { "NtQueryInformationFile", func_NtQueryInformationFile }, { "NtQueryInformationProcess", func_NtQueryInformationProcess }, { "NtQueryInformationThread", func_NtQueryInformationThread }, + { "NtQueryInformationToken", func_NtQueryInformationToken }, { "NtQueryKey", func_NtQueryKey }, { "NtQuerySystemEnvironmentValue", func_NtQuerySystemEnvironmentValue }, { "NtQuerySystemInformation", func_NtQuerySystemInformation }, @@ -129,6 +132,7 @@ const struct test winetest_testlist[] = { "NtSetInformationFile", func_NtSetInformationFile }, { "NtSetInformationProcess", func_NtSetInformationProcess }, { "NtSetInformationThread", func_NtSetInformationThread }, + { "NtSetInformationToken", func_NtSetInformationToken }, { "NtSetValueKey", func_NtSetValueKey}, { "NtSetVolumeInformationFile", func_NtSetVolumeInformationFile }, { "NtSystemInformation", func_NtSystemInformation },

1 0

[reactos] 01/01: [WIN32K] Conditionally enable IMM32
by Mark Jansen 09 Jun '22

09 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=81e0f74a7a150edb98e27… commit 81e0f74a7a150edb98e272c5cf86a36488422795 Author: Mark Jansen <mark.jansen(a)reactos.org> AuthorDate: Mon Jun 6 20:54:26 2022 +0200 Commit: Mark Jansen <mark.jansen(a)reactos.org> CommitDate: Wed Jun 8 19:19:59 2022 +0200 [WIN32K] Conditionally enable IMM32 MFC42 applications only expect an IME window when on a DBCS system, so they will capture this IME window as their 'main' window on non-DBCS systems. CORE-18212 --- win32ss/user/ntuser/simplecall.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/win32ss/user/ntuser/simplecall.c b/win32ss/user/ntuser/simplecall.c index b228746a9e4..b0e1d86f1d0 100644 --- a/win32ss/user/ntuser/simplecall.c +++ b/win32ss/user/ntuser/simplecall.c @@ -124,7 +124,16 @@ NtUserCallNoParam(DWORD Routine) break; case NOPARAM_ROUTINE_UPDATEPERUSERIMMENABLING: - gpsi->dwSRVIFlags |= SRVINFO_IMM32; // Always set. + // TODO: This should also check the registry! + // see https://www.pctipsbox.com/fix-available-for-ie7-memory-leaks-on-xp-sp3/ for more information + if (NLS_MB_CODE_PAGE_TAG) + { + gpsi->dwSRVIFlags |= SRVINFO_IMM32; + } + else + { + gpsi->dwSRVIFlags &= ~SRVINFO_IMM32; + } Result = TRUE; // Always return TRUE. break;

1 0

[reactos] 03/03: [SDK:REACTOS] Fix packing of GEN_ADDR structure, used in some ACPI tables
by Hervé Poussineau 08 Jun '22

08 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=63f042a5cd883ed795313… commit 63f042a5cd883ed795313be75406c4523654fce2 Author: Hervé Poussineau <hpoussin(a)reactos.org> AuthorDate: Wed Jun 8 07:55:27 2022 +0200 Commit: Hervé Poussineau <hpoussin(a)reactos.org> CommitDate: Wed Jun 8 07:58:27 2022 +0200 [SDK:REACTOS] Fix packing of GEN_ADDR structure, used in some ACPI tables --- sdk/include/reactos/drivers/acpi/acpi.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sdk/include/reactos/drivers/acpi/acpi.h b/sdk/include/reactos/drivers/acpi/acpi.h index e4231fefe32..fc4acff699b 100644 --- a/sdk/include/reactos/drivers/acpi/acpi.h +++ b/sdk/include/reactos/drivers/acpi/acpi.h @@ -64,6 +64,7 @@ typedef enum _BGRT_IMAGE_TYPE // // ACPI Generic Register Address // +#include <pshpack1.h> typedef struct _GEN_ADDR { UCHAR AddressSpaceID; @@ -76,7 +77,6 @@ typedef struct _GEN_ADDR // // ACPI BIOS Structures (packed) // -#include <pshpack1.h> typedef struct _RSDP { ULONGLONG Signature;

1 0

[reactos] 02/03: [WIN32SS:USER] Do not write error message at end of enumeration in UserEnumDisplayDevices()
by Hervé Poussineau 08 Jun '22

08 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=2915d16543a0da84b9efc… commit 2915d16543a0da84b9efca606759639d49b479fc Author: Hervé Poussineau <hpoussin(a)reactos.org> AuthorDate: Sun Jun 5 14:51:06 2022 +0200 Commit: Hervé Poussineau <hpoussin(a)reactos.org> CommitDate: Wed Jun 8 07:58:12 2022 +0200 [WIN32SS:USER] Do not write error message at end of enumeration in UserEnumDisplayDevices() --- win32ss/user/ntuser/display.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/win32ss/user/ntuser/display.c b/win32ss/user/ntuser/display.c index 5feb8077db6..8ce655fbb27 100644 --- a/win32ss/user/ntuser/display.c +++ b/win32ss/user/ntuser/display.c @@ -254,7 +254,10 @@ UserEnumDisplayDevices( if (!pGraphicsDevice) { /* No device found */ - ERR("No GRAPHICS_DEVICE found for '%wZ', iDevNum %lu\n", pustrDevice, iDevNum); + if (iDevNum == 0) + ERR("No GRAPHICS_DEVICE found for '%wZ', iDevNum %lu\n", pustrDevice, iDevNum); + else + TRACE("No GRAPHICS_DEVICE found for '%wZ', iDevNum %lu\n", pustrDevice, iDevNum); return STATUS_UNSUCCESSFUL; }

1 0

[reactos] 01/03: [WIN32SS:ENG] Fix handling of Acceleration.Level parameter (was not read anymore)
by Hervé Poussineau 08 Jun '22

08 Jun '22

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=cd8305494cfb7ee4f75c5… commit cd8305494cfb7ee4f75c52c0ec737a98a9297c34 Author: Hervé Poussineau <hpoussin(a)reactos.org> AuthorDate: Sun Jun 5 14:49:47 2022 +0200 Commit: Hervé Poussineau <hpoussin(a)reactos.org> CommitDate: Sun Jun 5 14:49:47 2022 +0200 [WIN32SS:ENG] Fix handling of Acceleration.Level parameter (was not read anymore) --- win32ss/gdi/eng/device.c | 43 +++++++++++++++++++++++++++++++++---------- win32ss/gdi/eng/device.h | 11 ++++++++--- win32ss/gdi/eng/ldevobj.c | 2 +- win32ss/gdi/eng/mdevobj.c | 2 ++ 4 files changed, 44 insertions(+), 14 deletions(-) diff --git a/win32ss/gdi/eng/device.c b/win32ss/gdi/eng/device.c index 3bd3827c9e7..7940a059752 100644 --- a/win32ss/gdi/eng/device.c +++ b/win32ss/gdi/eng/device.c @@ -167,21 +167,12 @@ EngpGetRegistryHandleFromDeviceMap( NTSTATUS EngpGetDisplayDriverParameters( _In_ PGRAPHICS_DEVICE pGraphicsDevice, - _Out_ PDEVMODEW pdm, - _Out_opt_ PDWORD pdwAccelerationLevel) + _Out_ PDEVMODEW pdm) { HKEY hKey; - DWORD dwDummy; NTSTATUS Status; RTL_QUERY_REGISTRY_TABLE DisplaySettingsTable[] = { - { - NULL, - RTL_QUERY_REGISTRY_DIRECT, - L"Acceleration.Level", - pdwAccelerationLevel ? pdwAccelerationLevel : &dwDummy, - REG_NONE, NULL, 0 - }, #define READ(field, str) \ { \ NULL, \ @@ -219,6 +210,38 @@ EngpGetDisplayDriverParameters( return Status; } +DWORD +EngpGetDisplayDriverAccelerationLevel( + _In_ PGRAPHICS_DEVICE pGraphicsDevice) +{ + HKEY hKey; + DWORD dwAccelerationLevel = 0; + RTL_QUERY_REGISTRY_TABLE DisplaySettingsTable[] = + { + { + NULL, + RTL_QUERY_REGISTRY_DIRECT, + L"Acceleration.Level", + &dwAccelerationLevel, + REG_NONE, NULL, 0 + }, + {0} + }; + + hKey = EngpGetRegistryHandleFromDeviceMap(pGraphicsDevice); + if (!hKey) + return 0; + + RtlQueryRegistryValues(RTL_REGISTRY_HANDLE, + (PWSTR)hKey, + DisplaySettingsTable, + NULL, + NULL); + ZwClose(hKey); + + return dwAccelerationLevel; +} + extern VOID UserRefreshDisplay(IN PPDEVOBJ ppdev); diff --git a/win32ss/gdi/eng/device.h b/win32ss/gdi/eng/device.h index 5791e5a5591..a7d352c6bbe 100644 --- a/win32ss/gdi/eng/device.h +++ b/win32ss/gdi/eng/device.h @@ -38,15 +38,20 @@ EngpUpdateGraphicsDeviceList(VOID); /* Read configuration of a graphics card from registry: * - pGraphicsDevice: instance of the graphics card * - pdm: on output, contains the values read in registry - * - pdwAccelerationLevel: acceleration level stored in registry * Return value: a STATUS_* value * Assume that pdm has already been zero-filled. * Note that dmFields is not updated. */ NTSTATUS EngpGetDisplayDriverParameters( _In_ PGRAPHICS_DEVICE pGraphicsDevice, - _Out_ PDEVMODEW pdm, - _Out_opt_ PDWORD pdwAccelerationLevel); + _Out_ PDEVMODEW pdm); + +/* Read acceleration level of a graphics card from registry + * - pGraphicsDevice: instance of the graphics card + * - Return value: acceleration level stored in registry */ +DWORD +EngpGetDisplayDriverAccelerationLevel( + _In_ PGRAPHICS_DEVICE pGraphicsDevice); CODE_SEG("INIT") NTSTATUS diff --git a/win32ss/gdi/eng/ldevobj.c b/win32ss/gdi/eng/ldevobj.c index b7626f92886..6408c20648f 100644 --- a/win32ss/gdi/eng/ldevobj.c +++ b/win32ss/gdi/eng/ldevobj.c @@ -750,7 +750,7 @@ LDEVOBJ_bProbeAndCaptureDevmode( /* At first, load information from registry */ RtlZeroMemory(&dmSearch, sizeof(dmSearch)); - Status = EngpGetDisplayDriverParameters(pGraphicsDevice, &dmSearch, NULL); + Status = EngpGetDisplayDriverParameters(pGraphicsDevice, &dmSearch); if (!NT_SUCCESS(Status)) { ERR("EngpGetDisplayDriverParameters() failed with status 0x%08x\n", Status); diff --git a/win32ss/gdi/eng/mdevobj.c b/win32ss/gdi/eng/mdevobj.c index 620e5451f8c..6badcc783bb 100644 --- a/win32ss/gdi/eng/mdevobj.c +++ b/win32ss/gdi/eng/mdevobj.c @@ -105,6 +105,8 @@ MDEVOBJ_Create( dmDefault.dmSize = sizeof(dmDefault); } + dwAccelerationLevel = EngpGetDisplayDriverAccelerationLevel(pGraphicsDevice); + /* Get or create a PDEV for these settings */ if (LDEVOBJ_bProbeAndCaptureDevmode(pGraphicsDevice, pdm ? pdm : &dmDefault, &localPdm, !pdm)) {

1 0

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs