IsProcessorFeaturePresent this function is just an analog of the CPUID instruction for high level languages.

To verify this, you can take a debugger and examine the code of this API function.
In any case, the OS takes all the information through the CPUID instruction.

Thanks. I think I will use this API function, much easier.
Maybe I will trace the API code after I start doing it.

0:000> uf IsProcessorFeaturePresent
kernel32!IsProcessorFeaturePresent:
00000000`77bbcb30 83f903          cmp     ecx,3
00000000`77bbcb33 7414            je      kernel32!IsProcessorFeaturePresent+0x19 (00000000`77bbcb49)

kernel32!IsProcessorFeaturePresent+0x5:
00000000`77bbcb35 83f907          cmp     ecx,7
00000000`77bbcb38 740f            je      kernel32!IsProcessorFeaturePresent+0x19 (00000000`77bbcb49)

kernel32!IsProcessorFeaturePresent+0xa:
00000000`77bbcb3a 83f940          cmp     ecx,40h
00000000`77bbcb3d 730a            jae     kernel32!IsProcessorFeaturePresent+0x19 (00000000`77bbcb49)

kernel32!IsProcessorFeaturePresent+0xf:
00000000`77bbcb3f 8bc1            mov     eax,ecx
00000000`77bbcb41 0fb6807402fe7f  movzx   eax,byte ptr SharedUserData+0x274 (00000000`7ffe0274)[rax]
00000000`77bbcb48 c3              ret

kernel32!IsProcessorFeaturePresent+0x19:
00000000`77bbcb49 33c0            xor     eax,eax
00000000`77bbcb4b c3              ret
    

...That is, to check all the capabilities of the CPU, you will need to call it 32 times, and each time it will read 1 byte from the KUSER_SHARED_DATA structure. Therefore, it is better to use the CPUID instruction, which returns a 32-bit mask with all the characteristics at once.

EDIT: Oops, maybe 2 x 32-bit masks, in Table 5.5 and Table 5.6.

Mat Quasar wrote:

EDIT: Oops, maybe 2 x 32-bit masks, in Table 5.5 and Table 5.6.

Yes, that's right.
I once wrote a similar program with a call CPUID, only I displayed the result on the console. You can see an example here:
https://codeby.net/threads/cpuid-identifikacija-processora.78279/

Function EAX=4. (Deterministic Cache Parameters)
Function EAX=8000_0001h (Extended Feature Bits)
Function EAX=8000_0006h (Extended L2 Cache Features)
Function EAX=8000_0008h (Virtual & Physical Address Sizes)

The experiments above showed that CPUID is initially unable to return some information. For example, it does not contain data such as: core code name, operating voltage threshold, socket type, power consumption, and manufacturing process technology value. Apparently, software like CPU-Z stores all this in its tables, which programmers meticulously collect manually. Databases of this kind are written based on the "Family/Model/Stepping" values ​​provided to us by the functionCPUID.EAX=1.

Moreover, the presented table is valid only for Intel processors, since AMD has a completely different numbering of functions.

Can I use your code for the following functions?

     mov    ecx,2        ; cycle
@@:  push   rcx
     xor    eax,eax 
     cpuid               ; clear cpu pipeline
     rdtsc 
     push   rax 
     invoke Sleep,1000   ; wait 1-sec..
     rdtsc 
     pop    rbx 
     sub    rax,rbx      ; difference
     pop    rcx
     dec    rcx 
     jnz    @b           ; RAX = tsc value    

So CPU-Z keeps a comprehensive database based on results returned by EAX register for EAX=1 CPUID instruction.

format   pe console
include 'win32ax.inc'
entry    start
;//-----------
.data
intel   db  10,' Intel',0
amd     db  10,' AMD',0
;//-----------
.code
start:  xor      edx,edx
        mov      eax,5
        mov      ebx,2
        div      ebx

        mov      eax,intel
        jz       @prn
        mov      eax,amd
@prn:   cinvoke  printf,eax

@exit:  cinvoke  _getch
        cinvoke  exit, 0
;//-----------
section '.idata' import data readable
library  msvcrt,'msvcrt.dll'
import   msvcrt,printf,'printf',exit,'exit',_getch,'_getch'    

According to my understanding, even if CPUID detect presence of a processor feature, it might not be supported by the OS, so I am thinking IsProcessorFeaturePresent can detect support of processor feature by both CPU and Windows.

calminstruction __fastfail value* ; program state unknown, end process, does not return
        asm     mov ecx,value
        asm     int 0x29
end calminstruction    

Previously, there was such a method for detecting the vendor Intel/AMD - I wonder if it works on new processors now, or AMD corrected the error based on the ZF flag?

I don't know how reliable it is, but can't we get CPU brand string from EAX = 0 CPUID instruction?

The KUSER_SHARED_DATA address maybe can get from TEB or PEB?