github.com/klauspost/cpuid/v2@v2.2.7/README.md (about)

     1  # cpuid
     2  Package cpuid provides information about the CPU running the current program.
     3  
     4  CPU features are detected on startup, and kept for fast access through the life of the application.
     5  Currently x86 / x64 (AMD64/i386) and ARM (ARM64) is supported, and no external C (cgo) code is used, which should make the library very easy to use.
     6  
     7  You can access the CPU information by accessing the shared CPU variable of the cpuid library.
     8  
     9  Package home: https://github.com/klauspost/cpuid
    10  
    11  [![PkgGoDev](https://pkg.go.dev/badge/github.com/klauspost/cpuid)](https://pkg.go.dev/github.com/klauspost/cpuid/v2)
    12  [![Go](https://github.com/klauspost/cpuid/actions/workflows/go.yml/badge.svg)](https://github.com/klauspost/cpuid/actions/workflows/go.yml)
    13  
    14  ## installing
    15  
    16  `go get -u github.com/klauspost/cpuid/v2` using modules.
    17  Drop `v2` for others.
    18  
    19  Installing binary:
    20  
    21  `go install github.com/klauspost/cpuid/v2/cmd/cpuid@latest`
    22  
    23  Or download binaries from release page: https://github.com/klauspost/cpuid/releases
    24  
    25  ### Homebrew
    26  
    27  For macOS/Linux users, you can install via [brew](https://brew.sh/)
    28  
    29  ```sh
    30  $ brew install cpuid
    31  ```
    32  
    33  ## example
    34  
    35  ```Go
    36  package main
    37  
    38  import (
    39  	"fmt"
    40  	"strings"
    41  
    42  	. "github.com/klauspost/cpuid/v2"
    43  )
    44  
    45  func main() {
    46  	// Print basic CPU information:
    47  	fmt.Println("Name:", CPU.BrandName)
    48  	fmt.Println("PhysicalCores:", CPU.PhysicalCores)
    49  	fmt.Println("ThreadsPerCore:", CPU.ThreadsPerCore)
    50  	fmt.Println("LogicalCores:", CPU.LogicalCores)
    51  	fmt.Println("Family", CPU.Family, "Model:", CPU.Model, "Vendor ID:", CPU.VendorID)
    52  	fmt.Println("Features:", strings.Join(CPU.FeatureSet(), ","))
    53  	fmt.Println("Cacheline bytes:", CPU.CacheLine)
    54  	fmt.Println("L1 Data Cache:", CPU.Cache.L1D, "bytes")
    55  	fmt.Println("L1 Instruction Cache:", CPU.Cache.L1I, "bytes")
    56  	fmt.Println("L2 Cache:", CPU.Cache.L2, "bytes")
    57  	fmt.Println("L3 Cache:", CPU.Cache.L3, "bytes")
    58  	fmt.Println("Frequency", CPU.Hz, "hz")
    59  
    60  	// Test if we have these specific features:
    61  	if CPU.Supports(SSE, SSE2) {
    62  		fmt.Println("We have Streaming SIMD 2 Extensions")
    63  	}
    64  }
    65  ```
    66  
    67  Sample output:
    68  ```
    69  >go run main.go
    70  Name: AMD Ryzen 9 3950X 16-Core Processor
    71  PhysicalCores: 16
    72  ThreadsPerCore: 2
    73  LogicalCores: 32
    74  Family 23 Model: 113 Vendor ID: AMD
    75  Features: ADX,AESNI,AVX,AVX2,BMI1,BMI2,CLMUL,CMOV,CX16,F16C,FMA3,HTT,HYPERVISOR,LZCNT,MMX,MMXEXT,NX,POPCNT,RDRAND,RDSEED,RDTSCP,SHA,SSE,SSE2,SSE3,SSE4,SSE42,SSE4A,SSSE3
    76  Cacheline bytes: 64
    77  L1 Data Cache: 32768 bytes
    78  L1 Instruction Cache: 32768 bytes
    79  L2 Cache: 524288 bytes
    80  L3 Cache: 16777216 bytes
    81  Frequency 0 hz
    82  We have Streaming SIMD 2 Extensions
    83  ```
    84  
    85  # usage
    86  
    87  The `cpuid.CPU` provides access to CPU features. Use `cpuid.CPU.Supports()` to check for CPU features.
    88  A faster `cpuid.CPU.Has()` is provided which will usually be inlined by the gc compiler.  
    89  
    90  To test a larger number of features, they can be combined using `f := CombineFeatures(CMOV, CMPXCHG8, X87, FXSR, MMX, SYSCALL, SSE, SSE2)`, etc.
    91  This can be using with `cpuid.CPU.HasAll(f)` to quickly test if all features are supported.
    92  
    93  Note that for some cpu/os combinations some features will not be detected.
    94  `amd64` has rather good support and should work reliably on all platforms.
    95  
    96  Note that hypervisors may not pass through all CPU features through to the guest OS,
    97  so even if your host supports a feature it may not be visible on guests.
    98  
    99  ## arm64 feature detection
   100  
   101  Not all operating systems provide ARM features directly 
   102  and there is no safe way to do so for the rest.
   103  
   104  Currently `arm64/linux` and `arm64/freebsd` should be quite reliable. 
   105  `arm64/darwin` adds features expected from the M1 processor, but a lot remains undetected.
   106  
   107  A `DetectARM()` can be used if you are able to control your deployment,
   108  it will detect CPU features, but may crash if the OS doesn't intercept the calls.
   109  A `-cpu.arm` flag for detecting unsafe ARM features can be added. See below.
   110   
   111  Note that currently only features are detected on ARM, 
   112  no additional information is currently available. 
   113  
   114  ## flags
   115  
   116  It is possible to add flags that affects cpu detection.
   117  
   118  For this the `Flags()` command is provided.
   119  
   120  This must be called *before* `flag.Parse()` AND after the flags have been parsed `Detect()` must be called.
   121  
   122  This means that any detection used in `init()` functions will not contain these flags.
   123  
   124  Example:
   125  
   126  ```Go
   127  package main
   128  
   129  import (
   130  	"flag"
   131  	"fmt"
   132  	"strings"
   133  
   134  	"github.com/klauspost/cpuid/v2"
   135  )
   136  
   137  func main() {
   138  	cpuid.Flags()
   139  	flag.Parse()
   140  	cpuid.Detect()
   141  
   142  	// Test if we have these specific features:
   143  	if cpuid.CPU.Supports(cpuid.SSE, cpuid.SSE2) {
   144  		fmt.Println("We have Streaming SIMD 2 Extensions")
   145  	}
   146  }
   147  ```
   148  
   149  ## commandline
   150  
   151  Download as binary from: https://github.com/klauspost/cpuid/releases
   152  
   153  Install from source:
   154  
   155  `go install github.com/klauspost/cpuid/v2/cmd/cpuid@latest`
   156  
   157  ### Example
   158  
   159  ```
   160  λ cpuid
   161  Name: AMD Ryzen 9 3950X 16-Core Processor
   162  Vendor String: AuthenticAMD
   163  Vendor ID: AMD
   164  PhysicalCores: 16
   165  Threads Per Core: 2
   166  Logical Cores: 32
   167  CPU Family 23 Model: 113
   168  Features: ADX,AESNI,AVX,AVX2,BMI1,BMI2,CLMUL,CLZERO,CMOV,CMPXCHG8,CPBOOST,CX16,F16C,FMA3,FXSR,FXSROPT,HTT,HYPERVISOR,LAHF,LZCNT,MCAOVERFLOW,MMX,MMXEXT,MOVBE,NX,OSXSAVE,POPCNT,RDRAND,RDSEED,RDTSCP,SCE,SHA,SSE,SSE2,SSE3,SSE4,SSE42,SSE4A,SSSE3,SUCCOR,X87,XSAVE
   169  Microarchitecture level: 3
   170  Cacheline bytes: 64
   171  L1 Instruction Cache: 32768 bytes
   172  L1 Data Cache: 32768 bytes
   173  L2 Cache: 524288 bytes
   174  L3 Cache: 16777216 bytes
   175  
   176  ```
   177  ### JSON Output:
   178  
   179  ```
   180  λ cpuid --json
   181  {
   182    "BrandName": "AMD Ryzen 9 3950X 16-Core Processor",
   183    "VendorID": 2,
   184    "VendorString": "AuthenticAMD",
   185    "PhysicalCores": 16,
   186    "ThreadsPerCore": 2,
   187    "LogicalCores": 32,
   188    "Family": 23,
   189    "Model": 113,
   190    "CacheLine": 64,
   191    "Hz": 0,
   192    "BoostFreq": 0,
   193    "Cache": {
   194      "L1I": 32768,
   195      "L1D": 32768,
   196      "L2": 524288,
   197      "L3": 16777216
   198    },
   199    "SGX": {
   200      "Available": false,
   201      "LaunchControl": false,
   202      "SGX1Supported": false,
   203      "SGX2Supported": false,
   204      "MaxEnclaveSizeNot64": 0,
   205      "MaxEnclaveSize64": 0,
   206      "EPCSections": null
   207    },
   208    "Features": [
   209      "ADX",
   210      "AESNI",
   211      "AVX",
   212      "AVX2",
   213      "BMI1",
   214      "BMI2",
   215      "CLMUL",
   216      "CLZERO",
   217      "CMOV",
   218      "CMPXCHG8",
   219      "CPBOOST",
   220      "CX16",
   221      "F16C",
   222      "FMA3",
   223      "FXSR",
   224      "FXSROPT",
   225      "HTT",
   226      "HYPERVISOR",
   227      "LAHF",
   228      "LZCNT",
   229      "MCAOVERFLOW",
   230      "MMX",
   231      "MMXEXT",
   232      "MOVBE",
   233      "NX",
   234      "OSXSAVE",
   235      "POPCNT",
   236      "RDRAND",
   237      "RDSEED",
   238      "RDTSCP",
   239      "SCE",
   240      "SHA",
   241      "SSE",
   242      "SSE2",
   243      "SSE3",
   244      "SSE4",
   245      "SSE42",
   246      "SSE4A",
   247      "SSSE3",
   248      "SUCCOR",
   249      "X87",
   250      "XSAVE"
   251    ],
   252    "X64Level": 3
   253  }
   254  ```
   255  
   256  ### Check CPU microarch level
   257  
   258  ```
   259  λ cpuid --check-level=3
   260  2022/03/18 17:04:40 AMD Ryzen 9 3950X 16-Core Processor
   261  2022/03/18 17:04:40 Microarchitecture level 3 is supported. Max level is 3.
   262  Exit Code 0
   263  
   264  λ cpuid --check-level=4
   265  2022/03/18 17:06:18 AMD Ryzen 9 3950X 16-Core Processor
   266  2022/03/18 17:06:18 Microarchitecture level 4 not supported. Max level is 3.
   267  Exit Code 1
   268  ```
   269  
   270  
   271  ## Available flags
   272  
   273  ### x86 & amd64 
   274  
   275  | Feature Flag       | Description                                                                                                                                                                        |
   276  |--------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
   277  | ADX                | Intel ADX (Multi-Precision Add-Carry Instruction Extensions)                                                                                                                       |
   278  | AESNI              | Advanced Encryption Standard New Instructions                                                                                                                                      |
   279  | AMD3DNOW           | AMD 3DNOW                                                                                                                                                                          |
   280  | AMD3DNOWEXT        | AMD 3DNowExt                                                                                                                                                                       |
   281  | AMXBF16            | Tile computational operations on BFLOAT16 numbers                                                                                                                                  |
   282  | AMXINT8            | Tile computational operations on 8-bit integers                                                                                                                                    |
   283  | AMXFP16            | Tile computational operations on FP16 numbers                                                                                                                                      |
   284  | AMXTILE            | Tile architecture                                                                                                                                                                  |
   285  | APX_F              | Intel APX                                                                                                                                                                          |
   286  | AVX                | AVX functions                                                                                                                                                                      |
   287  | AVX10              | If set the Intel AVX10 Converged Vector ISA is supported                                                                                                                           |
   288  | AVX10_128          | If set indicates that AVX10 128-bit vector support is present                                                                                                                      |
   289  | AVX10_256          | If set indicates that AVX10 256-bit vector support is present                                                                                                                      |
   290  | AVX10_512          | If set indicates that AVX10 512-bit vector support is present                                                                                                                      |
   291  | AVX2               | AVX2 functions                                                                                                                                                                     |
   292  | AVX512BF16         | AVX-512 BFLOAT16 Instructions                                                                                                                                                      |
   293  | AVX512BITALG       | AVX-512 Bit Algorithms                                                                                                                                                             |
   294  | AVX512BW           | AVX-512 Byte and Word Instructions                                                                                                                                                 |
   295  | AVX512CD           | AVX-512 Conflict Detection Instructions                                                                                                                                            |
   296  | AVX512DQ           | AVX-512 Doubleword and Quadword Instructions                                                                                                                                       |
   297  | AVX512ER           | AVX-512 Exponential and Reciprocal Instructions                                                                                                                                    |
   298  | AVX512F            | AVX-512 Foundation                                                                                                                                                                 |
   299  | AVX512FP16         | AVX-512 FP16 Instructions                                                                                                                                                          |
   300  | AVX512IFMA         | AVX-512 Integer Fused Multiply-Add Instructions                                                                                                                                    |
   301  | AVX512PF           | AVX-512 Prefetch Instructions                                                                                                                                                      |
   302  | AVX512VBMI         | AVX-512 Vector Bit Manipulation Instructions                                                                                                                                       |
   303  | AVX512VBMI2        | AVX-512 Vector Bit Manipulation Instructions, Version 2                                                                                                                            |
   304  | AVX512VL           | AVX-512 Vector Length Extensions                                                                                                                                                   |
   305  | AVX512VNNI         | AVX-512 Vector Neural Network Instructions                                                                                                                                         |
   306  | AVX512VP2INTERSECT | AVX-512 Intersect for D/Q                                                                                                                                                          |
   307  | AVX512VPOPCNTDQ    | AVX-512 Vector Population Count Doubleword and Quadword                                                                                                                            |
   308  | AVXIFMA            | AVX-IFMA instructions                                                                                                                                                              |
   309  | AVXNECONVERT       | AVX-NE-CONVERT instructions                                                                                                                                                        |
   310  | AVXSLOW            | Indicates the CPU performs 2 128 bit operations instead of one                                                                                                                     |
   311  | AVXVNNI            | AVX (VEX encoded) VNNI neural network instructions                                                                                                                                 |
   312  | AVXVNNIINT8        | AVX-VNNI-INT8 instructions                                                                                                                                                         |
   313  | BHI_CTRL           | Branch History Injection and Intra-mode Branch Target Injection / CVE-2022-0001, CVE-2022-0002 / INTEL-SA-00598                                                                    |
   314  | BMI1               | Bit Manipulation Instruction Set 1                                                                                                                                                 |
   315  | BMI2               | Bit Manipulation Instruction Set 2                                                                                                                                                 |
   316  | CETIBT             | Intel CET Indirect Branch Tracking                                                                                                                                                 |
   317  | CETSS              | Intel CET Shadow Stack                                                                                                                                                             |
   318  | CLDEMOTE           | Cache Line Demote                                                                                                                                                                  |
   319  | CLMUL              | Carry-less Multiplication                                                                                                                                                          |
   320  | CLZERO             | CLZERO instruction supported                                                                                                                                                       |
   321  | CMOV               | i686 CMOV                                                                                                                                                                          |
   322  | CMPCCXADD          | CMPCCXADD instructions                                                                                                                                                             |
   323  | CMPSB_SCADBS_SHORT | Fast short CMPSB and SCASB                                                                                                                                                         |
   324  | CMPXCHG8           | CMPXCHG8 instruction                                                                                                                                                               |
   325  | CPBOOST            | Core Performance Boost                                                                                                                                                             |
   326  | CPPC               | AMD: Collaborative Processor Performance Control                                                                                                                                   |
   327  | CX16               | CMPXCHG16B Instruction                                                                                                                                                             |
   328  | EFER_LMSLE_UNS     | AMD: =Core::X86::Msr::EFER[LMSLE] is not supported, and MBZ                                                                                                                        |
   329  | ENQCMD             | Enqueue Command                                                                                                                                                                    |
   330  | ERMS               | Enhanced REP MOVSB/STOSB                                                                                                                                                           |
   331  | F16C               | Half-precision floating-point conversion                                                                                                                                           |
   332  | FLUSH_L1D          | Flush L1D cache                                                                                                                                                                    |
   333  | FMA3               | Intel FMA 3. Does not imply AVX.                                                                                                                                                   |
   334  | FMA4               | Bulldozer FMA4 functions                                                                                                                                                           |
   335  | FP128              | AMD: When set, the internal FP/SIMD execution datapath is 128-bits wide                                                                                                            |
   336  | FP256              | AMD: When set, the internal FP/SIMD execution datapath is 256-bits wide                                                                                                            |
   337  | FSRM               | Fast Short Rep Mov                                                                                                                                                                 |
   338  | FXSR               | FXSAVE, FXRESTOR instructions, CR4 bit 9                                                                                                                                           |
   339  | FXSROPT            | FXSAVE/FXRSTOR optimizations                                                                                                                                                       |
   340  | GFNI               | Galois Field New Instructions. May require other features (AVX, AVX512VL,AVX512F) based on usage.                                                                                  |
   341  | HLE                | Hardware Lock Elision                                                                                                                                                              |
   342  | HRESET             | If set CPU supports history reset and the IA32_HRESET_ENABLE MSR                                                                                                                   |
   343  | HTT                | Hyperthreading (enabled)                                                                                                                                                           |
   344  | HWA                | Hardware assert supported. Indicates support for MSRC001_10                                                                                                                        |
   345  | HYBRID_CPU         | This part has CPUs of more than one type.                                                                                                                                          |
   346  | HYPERVISOR         | This bit has been reserved by Intel & AMD for use by hypervisors                                                                                                                   |
   347  | IA32_ARCH_CAP      | IA32_ARCH_CAPABILITIES MSR (Intel)                                                                                                                                                 |
   348  | IA32_CORE_CAP      | IA32_CORE_CAPABILITIES MSR                                                                                                                                                         |
   349  | IBPB               | Indirect Branch Restricted Speculation (IBRS) and Indirect Branch Predictor Barrier (IBPB)                                                                                         |
   350  | IBRS               | AMD: Indirect Branch Restricted Speculation                                                                                                                                        |
   351  | IBRS_PREFERRED     | AMD: IBRS is preferred over software solution                                                                                                                                      |
   352  | IBRS_PROVIDES_SMP  | AMD: IBRS provides Same Mode Protection                                                                                                                                            |
   353  | IBS                | Instruction Based Sampling (AMD)                                                                                                                                                   |
   354  | IBSBRNTRGT         | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
   355  | IBSFETCHSAM        | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
   356  | IBSFFV             | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
   357  | IBSOPCNT           | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
   358  | IBSOPCNTEXT        | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
   359  | IBSOPSAM           | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
   360  | IBSRDWROPCNT       | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
   361  | IBSRIPINVALIDCHK   | Instruction Based Sampling Feature (AMD)                                                                                                                                           |
   362  | IBS_FETCH_CTLX     | AMD: IBS fetch control extended MSR supported                                                                                                                                      |
   363  | IBS_OPDATA4        | AMD: IBS op data 4 MSR supported                                                                                                                                                   |
   364  | IBS_OPFUSE         | AMD: Indicates support for IbsOpFuse                                                                                                                                               |
   365  | IBS_PREVENTHOST    | Disallowing IBS use by the host supported                                                                                                                                          |
   366  | IBS_ZEN4           | Fetch and Op IBS support IBS extensions added with Zen4                                                                                                                            |
   367  | IDPRED_CTRL        | IPRED_DIS                                                                                                                                                                          |
   368  | INT_WBINVD         | WBINVD/WBNOINVD are interruptible.                                                                                                                                                 |
   369  | INVLPGB            | NVLPGB and TLBSYNC instruction supported                                                                                                                                           |
   370  | KEYLOCKER          | Key locker                                                                                                                                                                         |
   371  | KEYLOCKERW         | Key locker wide                                                                                                                                                                    |
   372  | LAHF               | LAHF/SAHF in long mode                                                                                                                                                             |
   373  | LAM                | If set, CPU supports Linear Address Masking                                                                                                                                        |
   374  | LBRVIRT            | LBR virtualization                                                                                                                                                                 |
   375  | LZCNT              | LZCNT instruction                                                                                                                                                                  |
   376  | MCAOVERFLOW        | MCA overflow recovery support.                                                                                                                                                     |
   377  | MCDT_NO            | Processor do not exhibit MXCSR Configuration Dependent Timing behavior and do not need to mitigate it.                                                                             |
   378  | MCOMMIT            | MCOMMIT instruction supported                                                                                                                                                      |
   379  | MD_CLEAR           | VERW clears CPU buffers                                                                                                                                                            |
   380  | MMX                | standard MMX                                                                                                                                                                       |
   381  | MMXEXT             | SSE integer functions or AMD MMX ext                                                                                                                                               |
   382  | MOVBE              | MOVBE instruction (big-endian)                                                                                                                                                     |
   383  | MOVDIR64B          | Move 64 Bytes as Direct Store                                                                                                                                                      |
   384  | MOVDIRI            | Move Doubleword as Direct Store                                                                                                                                                    |
   385  | MOVSB_ZL           | Fast Zero-Length MOVSB                                                                                                                                                             |
   386  | MPX                | Intel MPX (Memory Protection Extensions)                                                                                                                                           |
   387  | MOVU               | MOVU SSE instructions are more efficient and should be preferred to SSE	MOVL/MOVH. MOVUPS is more efficient than MOVLPS/MOVHPS. MOVUPD is more efficient than MOVLPD/MOVHPD        |
   388  | MSRIRC             | Instruction Retired Counter MSR available                                                                                                                                          |
   389  | MSRLIST            | Read/Write List of Model Specific Registers                                                                                                                                        |
   390  | MSR_PAGEFLUSH      | Page Flush MSR available                                                                                                                                                           |
   391  | NRIPS              | Indicates support for NRIP save on VMEXIT                                                                                                                                          |
   392  | NX                 | NX (No-Execute) bit                                                                                                                                                                |
   393  | OSXSAVE            | XSAVE enabled by OS                                                                                                                                                                |
   394  | PCONFIG            | PCONFIG for Intel Multi-Key Total Memory Encryption                                                                                                                                |
   395  | POPCNT             | POPCNT instruction                                                                                                                                                                 |
   396  | PPIN               | AMD: Protected Processor Inventory Number support. Indicates that Protected Processor Inventory Number (PPIN) capability can be enabled                                            |
   397  | PREFETCHI          | PREFETCHIT0/1 instructions                                                                                                                                                         |
   398  | PSFD               | Predictive Store Forward Disable                                                                                                                                                   |
   399  | RDPRU              | RDPRU instruction supported                                                                                                                                                        |
   400  | RDRAND             | RDRAND instruction is available                                                                                                                                                    |
   401  | RDSEED             | RDSEED instruction is available                                                                                                                                                    |
   402  | RDTSCP             | RDTSCP Instruction                                                                                                                                                                 |
   403  | RRSBA_CTRL         | Restricted RSB Alternate                                                                                                                                                           |
   404  | RTM                | Restricted Transactional Memory                                                                                                                                                    |
   405  | RTM_ALWAYS_ABORT   | Indicates that the loaded microcode is forcing RTM abort.                                                                                                                          |
   406  | SERIALIZE          | Serialize Instruction Execution                                                                                                                                                    |
   407  | SEV                | AMD Secure Encrypted Virtualization supported                                                                                                                                      |
   408  | SEV_64BIT          | AMD SEV guest execution only allowed from a 64-bit host                                                                                                                            |
   409  | SEV_ALTERNATIVE    | AMD SEV Alternate Injection supported                                                                                                                                              |
   410  | SEV_DEBUGSWAP      | Full debug state swap supported for SEV-ES guests                                                                                                                                  |
   411  | SEV_ES             | AMD SEV Encrypted State supported                                                                                                                                                  |
   412  | SEV_RESTRICTED     | AMD SEV Restricted Injection supported                                                                                                                                             |
   413  | SEV_SNP            | AMD SEV Secure Nested Paging supported                                                                                                                                             |
   414  | SGX                | Software Guard Extensions                                                                                                                                                          |
   415  | SGXLC              | Software Guard Extensions Launch Control                                                                                                                                           |
   416  | SHA                | Intel SHA Extensions                                                                                                                                                               |
   417  | SME                | AMD Secure Memory Encryption supported                                                                                                                                             |
   418  | SME_COHERENT       | AMD Hardware cache coherency across encryption domains enforced                                                                                                                    |
   419  | SPEC_CTRL_SSBD     | Speculative Store Bypass Disable                                                                                                                                                   |
   420  | SRBDS_CTRL         | SRBDS mitigation MSR available                                                                                                                                                     |
   421  | SSE                | SSE functions                                                                                                                                                                      |
   422  | SSE2               | P4 SSE functions                                                                                                                                                                   |
   423  | SSE3               | Prescott SSE3 functions                                                                                                                                                            |
   424  | SSE4               | Penryn SSE4.1 functions                                                                                                                                                            |
   425  | SSE42              | Nehalem SSE4.2 functions                                                                                                                                                           |
   426  | SSE4A              | AMD Barcelona microarchitecture SSE4a instructions                                                                                                                                 |
   427  | SSSE3              | Conroe SSSE3 functions                                                                                                                                                             |
   428  | STIBP              | Single Thread Indirect Branch Predictors                                                                                                                                           |
   429  | STIBP_ALWAYSON     | AMD: Single Thread Indirect Branch Prediction Mode has Enhanced Performance and may be left Always On                                                                              |
   430  | STOSB_SHORT        | Fast short STOSB                                                                                                                                                                   |
   431  | SUCCOR             | Software uncorrectable error containment and recovery capability.                                                                                                                  |
   432  | SVM                | AMD Secure Virtual Machine                                                                                                                                                         |
   433  | SVMDA              | Indicates support for the SVM decode assists.                                                                                                                                      |
   434  | SVMFBASID          | SVM, Indicates that TLB flush events, including CR3 writes and CR4.PGE toggles, flush only the current ASID's TLB entries. Also indicates support for the extended VMCBTLB_Control |
   435  | SVML               | AMD SVM lock. Indicates support for SVM-Lock.                                                                                                                                      |
   436  | SVMNP              | AMD SVM nested paging                                                                                                                                                              |
   437  | SVMPF              | SVM pause intercept filter. Indicates support for the pause intercept filter                                                                                                       |
   438  | SVMPFT             | SVM PAUSE filter threshold. Indicates support for the PAUSE filter cycle count threshold                                                                                           |
   439  | SYSCALL            | System-Call Extension (SCE): SYSCALL and SYSRET instructions.                                                                                                                      |
   440  | SYSEE              | SYSENTER and SYSEXIT instructions                                                                                                                                                  |
   441  | TBM                | AMD Trailing Bit Manipulation                                                                                                                                                      |
   442  | TDX_GUEST          | Intel Trust Domain Extensions Guest                                                                                                                                                |
   443  | TLB_FLUSH_NESTED   | AMD: Flushing includes all the nested translations for guest translations                                                                                                          |
   444  | TME                | Intel Total Memory Encryption. The following MSRs are supported: IA32_TME_CAPABILITY, IA32_TME_ACTIVATE, IA32_TME_EXCLUDE_MASK, and IA32_TME_EXCLUDE_BASE.                         |
   445  | TOPEXT             | TopologyExtensions: topology extensions support. Indicates support for CPUID Fn8000_001D_EAX_x[N:0]-CPUID Fn8000_001E_EDX.                                                         |
   446  | TSCRATEMSR         | MSR based TSC rate control. Indicates support for MSR TSC ratio MSRC000_0104                                                                                                       |
   447  | TSXLDTRK           | Intel TSX Suspend Load Address Tracking                                                                                                                                            |
   448  | VAES               | Vector AES. AVX(512) versions requires additional checks.                                                                                                                          |
   449  | VMCBCLEAN          | VMCB clean bits. Indicates support for VMCB clean bits.                                                                                                                            |
   450  | VMPL               | AMD VM Permission Levels supported                                                                                                                                                 |
   451  | VMSA_REGPROT       | AMD VMSA Register Protection supported                                                                                                                                             |
   452  | VMX                | Virtual Machine Extensions                                                                                                                                                         |
   453  | VPCLMULQDQ         | Carry-Less Multiplication Quadword. Requires AVX for 3 register versions.                                                                                                          |
   454  | VTE                | AMD Virtual Transparent Encryption supported                                                                                                                                       |
   455  | WAITPKG            | TPAUSE, UMONITOR, UMWAIT                                                                                                                                                           |
   456  | WBNOINVD           | Write Back and Do Not Invalidate Cache                                                                                                                                             |
   457  | WRMSRNS            | Non-Serializing Write to Model Specific Register                                                                                                                                   |
   458  | X87                | FPU                                                                                                                                                                                |
   459  | XGETBV1            | Supports XGETBV with ECX = 1                                                                                                                                                       |
   460  | XOP                | Bulldozer XOP functions                                                                                                                                                            |
   461  | XSAVE              | XSAVE, XRESTOR, XSETBV, XGETBV                                                                                                                                                     |
   462  | XSAVEC             | Supports XSAVEC and the compacted form of XRSTOR.                                                                                                                                  |
   463  | XSAVEOPT           | XSAVEOPT available                                                                                                                                                                 |
   464  | XSAVES             | Supports XSAVES/XRSTORS and IA32_XSS                                                                                                                                               |
   465  
   466  # ARM features:
   467  
   468  | Feature Flag | Description                                                      |
   469  |--------------|------------------------------------------------------------------|
   470  | AESARM       | AES instructions                                                 |
   471  | ARMCPUID     | Some CPU ID registers readable at user-level                     |
   472  | ASIMD        | Advanced SIMD                                                    |
   473  | ASIMDDP      | SIMD Dot Product                                                 |
   474  | ASIMDHP      | Advanced SIMD half-precision floating point                      |
   475  | ASIMDRDM     | Rounding Double Multiply Accumulate/Subtract (SQRDMLAH/SQRDMLSH) |
   476  | ATOMICS      | Large System Extensions (LSE)                                    |
   477  | CRC32        | CRC32/CRC32C instructions                                        |
   478  | DCPOP        | Data cache clean to Point of Persistence (DC CVAP)               |
   479  | EVTSTRM      | Generic timer                                                    |
   480  | FCMA         | Floatin point complex number addition and multiplication         |
   481  | FP           | Single-precision and double-precision floating point             |
   482  | FPHP         | Half-precision floating point                                    |
   483  | GPA          | Generic Pointer Authentication                                   |
   484  | JSCVT        | Javascript-style double->int convert (FJCVTZS)                   |
   485  | LRCPC        | Weaker release consistency (LDAPR, etc)                          |
   486  | PMULL        | Polynomial Multiply instructions (PMULL/PMULL2)                  |
   487  | SHA1         | SHA-1 instructions (SHA1C, etc)                                  |
   488  | SHA2         | SHA-2 instructions (SHA256H, etc)                                |
   489  | SHA3         | SHA-3 instructions (EOR3, RAXI, XAR, BCAX)                       |
   490  | SHA512       | SHA512 instructions                                              |
   491  | SM3          | SM3 instructions                                                 |
   492  | SM4          | SM4 instructions                                                 |
   493  | SVE          | Scalable Vector Extension                                        |
   494  
   495  # license
   496  
   497  This code is published under an MIT license. See LICENSE file for more information.