From patchwork Sat Jul 10 17:21:46 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "H.J. Lu" X-Patchwork-Id: 44307 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id D15AF385E821 for ; Sat, 10 Jul 2021 17:22:15 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org D15AF385E821 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1625937735; bh=4nMBOPvXSfHpXNo7sI3xB6iZosYoa+Nrn5ttr9MROI4=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:From; b=XrGwrOgJOvuKRSDgB/0nBaPbGzDC1P/g2hZZKQVnB+QhuK5S9qLwhsibn692cTYh2 NOpxJYQ5dic9aMcdMjQd+WoKPBMulEfU4XxD2bjI7lpG46ROpiURRplY97r9+JXKLP rEYsnwlZBEIqIfjOcPYDj+kAW57vjOWKaGvEC6XY= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-pg1-x533.google.com (mail-pg1-x533.google.com [IPv6:2607:f8b0:4864:20::533]) by sourceware.org (Postfix) with ESMTPS id 8F25B3858424 for ; Sat, 10 Jul 2021 17:21:49 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 8F25B3858424 Received: by mail-pg1-x533.google.com with SMTP id v7so13391259pgl.2 for ; Sat, 10 Jul 2021 10:21:49 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=4nMBOPvXSfHpXNo7sI3xB6iZosYoa+Nrn5ttr9MROI4=; b=KwQuP/7UGQz1HDqHWOfNlMdfUbIdrjYro1CkcIy+yQw0hYUgYRmGkGcD3SVIeLRJMw J7l9fclJvXhNX9jep1dMZSkl+tG5bgoedKSdv0ENVye7Q+kD2utfdIIcHpdR4DlsrrPf eO0JWhijqVOVOOjlFQNi+bobxh6EB88bI2vDYTc0SO+Yx1iG/hsIopavSwx8gEVkmVJR /QiosSKCi7N4KIGA7mtpAKzciDj+ezoD6NXDvBse3ZnKs7YDeH+aDIcVALVNdGaTke87 YXUEtvFxNYRxn1DScWr27uT53wKBWsiVeIn6LxbY9HqF0R8WZ6kK1Lv16wrnEvDVatOw 79Pg== X-Gm-Message-State: AOAM5311JBOgq4PaVpFKvq2o44NrBR5x3zsdpRsiSrIBy/NO04BNJqJZ BPN/2E3nUI7RLTnXXEkAl6mXNx4tTA4= X-Google-Smtp-Source: ABdhPJxz3orlwqR6hGbSwPRAfQdTAmf80zlzXnAucBNwahsN+BDA3T6ZrsREI0rg2Mkxe3LWcjz3SA== X-Received: by 2002:a65:6118:: with SMTP id z24mr44444514pgu.325.1625937708417; Sat, 10 Jul 2021 10:21:48 -0700 (PDT) Received: from gnu-cfl-2.localdomain ([172.56.39.115]) by smtp.gmail.com with ESMTPSA id n23sm8557366pjq.2.2021.07.10.10.21.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 10 Jul 2021 10:21:48 -0700 (PDT) Received: from gnu-cfl-2.. (localhost [IPv6:::1]) by gnu-cfl-2.localdomain (Postfix) with ESMTP id 50150C0063; Sat, 10 Jul 2021 10:21:46 -0700 (PDT) To: libc-alpha@sourceware.org Subject: [PATCH] x86: Install [BZ #27958] Date: Sat, 10 Jul 2021 10:21:46 -0700 Message-Id: <20210710172146.3301576-1-hjl.tools@gmail.com> X-Mailer: git-send-email 2.31.1 MIME-Version: 1.0 X-Spam-Status: No, score=-3032.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, UPPERCASE_50_75 autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: "H.J. Lu via Libc-alpha" From: "H.J. Lu" Reply-To: "H.J. Lu" Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" 1. Install for which includes . 2. Rename HAS_CPU_FEATURE to CPU_FEATURE_PRESENT which checks if the processor has the feature. 3. Rename CPU_FEATURE_USABLE to CPU_FEATURE_POSSIBLE which checks if the feature may be supported by the operating system. Information from CPUID may not be sufficient to indicate if a feature is usable since additional information may be needed from the Linux kernel to determine if the feature can be used. This fixes BZ #27958. --- manual/platform.texi | 16 +- sysdeps/x86/Makefile | 2 +- sysdeps/x86/bits/platform/x86.h | 2 +- sysdeps/x86/cpu-features.c | 176 +++---- sysdeps/x86/dl-diagnostics-cpu.c | 4 +- sysdeps/x86/include/cpu-features.h | 20 +- sysdeps/x86/sys/platform/x86.h | 14 +- sysdeps/x86/tst-cet-legacy-10.c | 8 +- sysdeps/x86/tst-cpu-features-supports.c | 178 +++---- sysdeps/x86/tst-get-cpu-features.c | 670 ++++++++++++------------ sysdeps/x86/tst-ifunc-isa.h | 12 +- sysdeps/x86/tst-string-rtm.h | 2 +- sysdeps/x86_64/fpu/math-tests-arch.h | 6 +- 13 files changed, 557 insertions(+), 553 deletions(-) diff --git a/manual/platform.texi b/manual/platform.texi index 037dfc4f20..ef71d6af0d 100644 --- a/manual/platform.texi +++ b/manual/platform.texi @@ -148,14 +148,14 @@ Return a pointer to x86 CPU feature structure used by query macros for x86 CPU feature @var{leaf}. @end deftypefun -@deftypefn Macro int HAS_CPU_FEATURE (@var{name}) +@deftypefn Macro int CPU_FEATURE_PRESENT (@var{name}) This macro returns a nonzero value (true) if the processor has the feature @var{name}. @end deftypefn -@deftypefn Macro int CPU_FEATURE_USABLE (@var{name}) +@deftypefn Macro int CPU_FEATURE_POSSIBLE (@var{name}) This macro returns a nonzero value (true) if the processor has the feature -@var{name} and the feature is supported by the operating system. +@var{name} and the feature may be supported by the operating system. @end deftypefn The supported processor features are: @@ -682,20 +682,20 @@ You could query if a processor supports @code{AVX} with: #include int -support_avx (void) +avx_present (void) @{ - return HAS_CPU_FEATURE (AVX); + return CPU_FEATURE_PRESENT (AVX); @} @end smallexample -and if @code{AVX} is usable with: +and if @code{AVX} may be supported with: @smallexample #include int -usable_avx (void) +avx_possible (void) @{ - return CPU_FEATURE_USABLE (AVX); + return CPU_FEATURE_POSSIBLE (AVX); @} @end smallexample diff --git a/sysdeps/x86/Makefile b/sysdeps/x86/Makefile index 346ec491b3..567ea54243 100644 --- a/sysdeps/x86/Makefile +++ b/sysdeps/x86/Makefile @@ -5,7 +5,7 @@ endif ifeq ($(subdir),elf) sysdep_routines += get-cpuid-feature-leaf sysdep-dl-routines += dl-get-cpu-features -sysdep_headers += sys/platform/x86.h +sysdep_headers += sys/platform/x86.h bits/platform/x86.h CFLAGS-get-cpuid-feature-leaf.o += $(no-stack-protector) diff --git a/sysdeps/x86/bits/platform/x86.h b/sysdeps/x86/bits/platform/x86.h index 5509b1ad87..aec793f034 100644 --- a/sysdeps/x86/bits/platform/x86.h +++ b/sysdeps/x86/bits/platform/x86.h @@ -36,7 +36,7 @@ enum struct cpuid_feature { unsigned int cpuid_array[4]; - unsigned int usable_array[4]; + unsigned int possible_array[4]; }; enum cpuid_register_index diff --git a/sysdeps/x86/cpu-features.c b/sysdeps/x86/cpu-features.c index 563a206ac1..1b1a21468c 100644 --- a/sysdeps/x86/cpu-features.c +++ b/sysdeps/x86/cpu-features.c @@ -44,65 +44,65 @@ update_usable (struct cpu_features *cpu_features) { /* Copy the cpuid bits to usable bits for CPU featuress whose usability in user space can be detected without additonal OS support. */ - CPU_FEATURE_SET_USABLE (cpu_features, SSE3); - CPU_FEATURE_SET_USABLE (cpu_features, PCLMULQDQ); - CPU_FEATURE_SET_USABLE (cpu_features, SSSE3); - CPU_FEATURE_SET_USABLE (cpu_features, CMPXCHG16B); - CPU_FEATURE_SET_USABLE (cpu_features, SSE4_1); - CPU_FEATURE_SET_USABLE (cpu_features, SSE4_2); - CPU_FEATURE_SET_USABLE (cpu_features, MOVBE); - CPU_FEATURE_SET_USABLE (cpu_features, POPCNT); - CPU_FEATURE_SET_USABLE (cpu_features, AES); - CPU_FEATURE_SET_USABLE (cpu_features, OSXSAVE); - CPU_FEATURE_SET_USABLE (cpu_features, TSC); - CPU_FEATURE_SET_USABLE (cpu_features, CX8); - CPU_FEATURE_SET_USABLE (cpu_features, CMOV); - CPU_FEATURE_SET_USABLE (cpu_features, CLFSH); - CPU_FEATURE_SET_USABLE (cpu_features, MMX); - CPU_FEATURE_SET_USABLE (cpu_features, FXSR); - CPU_FEATURE_SET_USABLE (cpu_features, SSE); - CPU_FEATURE_SET_USABLE (cpu_features, SSE2); - CPU_FEATURE_SET_USABLE (cpu_features, HTT); - CPU_FEATURE_SET_USABLE (cpu_features, BMI1); - CPU_FEATURE_SET_USABLE (cpu_features, HLE); - CPU_FEATURE_SET_USABLE (cpu_features, BMI2); - CPU_FEATURE_SET_USABLE (cpu_features, ERMS); - CPU_FEATURE_SET_USABLE (cpu_features, RDSEED); - CPU_FEATURE_SET_USABLE (cpu_features, ADX); - CPU_FEATURE_SET_USABLE (cpu_features, CLFLUSHOPT); - CPU_FEATURE_SET_USABLE (cpu_features, CLWB); - CPU_FEATURE_SET_USABLE (cpu_features, SHA); - CPU_FEATURE_SET_USABLE (cpu_features, PREFETCHWT1); - CPU_FEATURE_SET_USABLE (cpu_features, OSPKE); - CPU_FEATURE_SET_USABLE (cpu_features, WAITPKG); - CPU_FEATURE_SET_USABLE (cpu_features, GFNI); - CPU_FEATURE_SET_USABLE (cpu_features, RDPID); - CPU_FEATURE_SET_USABLE (cpu_features, RDRAND); - CPU_FEATURE_SET_USABLE (cpu_features, CLDEMOTE); - CPU_FEATURE_SET_USABLE (cpu_features, MOVDIRI); - CPU_FEATURE_SET_USABLE (cpu_features, MOVDIR64B); - CPU_FEATURE_SET_USABLE (cpu_features, FSRM); - CPU_FEATURE_SET_USABLE (cpu_features, RTM_ALWAYS_ABORT); - CPU_FEATURE_SET_USABLE (cpu_features, SERIALIZE); - CPU_FEATURE_SET_USABLE (cpu_features, TSXLDTRK); - CPU_FEATURE_SET_USABLE (cpu_features, LAHF64_SAHF64); - CPU_FEATURE_SET_USABLE (cpu_features, LZCNT); - CPU_FEATURE_SET_USABLE (cpu_features, SSE4A); - CPU_FEATURE_SET_USABLE (cpu_features, PREFETCHW); - CPU_FEATURE_SET_USABLE (cpu_features, TBM); - CPU_FEATURE_SET_USABLE (cpu_features, RDTSCP); - CPU_FEATURE_SET_USABLE (cpu_features, WBNOINVD); - CPU_FEATURE_SET_USABLE (cpu_features, FZLRM); - CPU_FEATURE_SET_USABLE (cpu_features, FSRS); - CPU_FEATURE_SET_USABLE (cpu_features, FSRCS); - CPU_FEATURE_SET_USABLE (cpu_features, PTWRITE); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SSE3); + CPU_FEATURE_SET_POSSIBLE (cpu_features, PCLMULQDQ); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SSSE3); + CPU_FEATURE_SET_POSSIBLE (cpu_features, CMPXCHG16B); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SSE4_1); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SSE4_2); + CPU_FEATURE_SET_POSSIBLE (cpu_features, MOVBE); + CPU_FEATURE_SET_POSSIBLE (cpu_features, POPCNT); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AES); + CPU_FEATURE_SET_POSSIBLE (cpu_features, OSXSAVE); + CPU_FEATURE_SET_POSSIBLE (cpu_features, TSC); + CPU_FEATURE_SET_POSSIBLE (cpu_features, CX8); + CPU_FEATURE_SET_POSSIBLE (cpu_features, CMOV); + CPU_FEATURE_SET_POSSIBLE (cpu_features, CLFSH); + CPU_FEATURE_SET_POSSIBLE (cpu_features, MMX); + CPU_FEATURE_SET_POSSIBLE (cpu_features, FXSR); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SSE); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SSE2); + CPU_FEATURE_SET_POSSIBLE (cpu_features, HTT); + CPU_FEATURE_SET_POSSIBLE (cpu_features, BMI1); + CPU_FEATURE_SET_POSSIBLE (cpu_features, HLE); + CPU_FEATURE_SET_POSSIBLE (cpu_features, BMI2); + CPU_FEATURE_SET_POSSIBLE (cpu_features, ERMS); + CPU_FEATURE_SET_POSSIBLE (cpu_features, RDSEED); + CPU_FEATURE_SET_POSSIBLE (cpu_features, ADX); + CPU_FEATURE_SET_POSSIBLE (cpu_features, CLFLUSHOPT); + CPU_FEATURE_SET_POSSIBLE (cpu_features, CLWB); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SHA); + CPU_FEATURE_SET_POSSIBLE (cpu_features, PREFETCHWT1); + CPU_FEATURE_SET_POSSIBLE (cpu_features, OSPKE); + CPU_FEATURE_SET_POSSIBLE (cpu_features, WAITPKG); + CPU_FEATURE_SET_POSSIBLE (cpu_features, GFNI); + CPU_FEATURE_SET_POSSIBLE (cpu_features, RDPID); + CPU_FEATURE_SET_POSSIBLE (cpu_features, RDRAND); + CPU_FEATURE_SET_POSSIBLE (cpu_features, CLDEMOTE); + CPU_FEATURE_SET_POSSIBLE (cpu_features, MOVDIRI); + CPU_FEATURE_SET_POSSIBLE (cpu_features, MOVDIR64B); + CPU_FEATURE_SET_POSSIBLE (cpu_features, FSRM); + CPU_FEATURE_SET_POSSIBLE (cpu_features, RTM_ALWAYS_ABORT); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SERIALIZE); + CPU_FEATURE_SET_POSSIBLE (cpu_features, TSXLDTRK); + CPU_FEATURE_SET_POSSIBLE (cpu_features, LAHF64_SAHF64); + CPU_FEATURE_SET_POSSIBLE (cpu_features, LZCNT); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SSE4A); + CPU_FEATURE_SET_POSSIBLE (cpu_features, PREFETCHW); + CPU_FEATURE_SET_POSSIBLE (cpu_features, TBM); + CPU_FEATURE_SET_POSSIBLE (cpu_features, RDTSCP); + CPU_FEATURE_SET_POSSIBLE (cpu_features, WBNOINVD); + CPU_FEATURE_SET_POSSIBLE (cpu_features, FZLRM); + CPU_FEATURE_SET_POSSIBLE (cpu_features, FSRS); + CPU_FEATURE_SET_POSSIBLE (cpu_features, FSRCS); + CPU_FEATURE_SET_POSSIBLE (cpu_features, PTWRITE); if (!CPU_FEATURES_CPU_P (cpu_features, RTM_ALWAYS_ABORT)) - CPU_FEATURE_SET_USABLE (cpu_features, RTM); + CPU_FEATURE_SET_POSSIBLE (cpu_features, RTM); #if CET_ENABLED - CPU_FEATURE_SET_USABLE (cpu_features, IBT); - CPU_FEATURE_SET_USABLE (cpu_features, SHSTK); + CPU_FEATURE_SET_POSSIBLE (cpu_features, IBT); + CPU_FEATURE_SET_POSSIBLE (cpu_features, SHSTK); #endif /* Can we call xgetbv? */ @@ -131,17 +131,17 @@ update_usable (struct cpu_features *cpu_features) |= bit_arch_AVX_Fast_Unaligned_Load; } /* Determine if AVX-VNNI is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX_VNNI); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX_VNNI); /* Determine if FMA is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, FMA); + CPU_FEATURE_SET_POSSIBLE (cpu_features, FMA); /* Determine if VAES is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, VAES); + CPU_FEATURE_SET_POSSIBLE (cpu_features, VAES); /* Determine if VPCLMULQDQ is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, VPCLMULQDQ); + CPU_FEATURE_SET_POSSIBLE (cpu_features, VPCLMULQDQ); /* Determine if XOP is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, XOP); + CPU_FEATURE_SET_POSSIBLE (cpu_features, XOP); /* Determine if F16C is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, F16C); + CPU_FEATURE_SET_POSSIBLE (cpu_features, F16C); } /* Check if OPMASK state, upper 256-bit of ZMM0-ZMM15 and @@ -155,41 +155,41 @@ update_usable (struct cpu_features *cpu_features) { CPU_FEATURE_SET (cpu_features, AVX512F); /* Determine if AVX512CD is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512CD); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512CD); /* Determine if AVX512ER is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512ER); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512ER); /* Determine if AVX512PF is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512PF); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512PF); /* Determine if AVX512VL is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512VL); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512VL); /* Determine if AVX512DQ is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512DQ); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512DQ); /* Determine if AVX512BW is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512BW); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512BW); /* Determine if AVX512_4FMAPS is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512_4FMAPS); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_4FMAPS); /* Determine if AVX512_4VNNIW is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512_4VNNIW); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_4VNNIW); /* Determine if AVX512_BITALG is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512_BITALG); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_BITALG); /* Determine if AVX512_IFMA is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512_IFMA); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_IFMA); /* Determine if AVX512_VBMI is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512_VBMI); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_VBMI); /* Determine if AVX512_VBMI2 is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512_VBMI2); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_VBMI2); /* Determine if is AVX512_VNNI usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512_VNNI); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_VNNI); /* Determine if AVX512_VPOPCNTDQ is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_VPOPCNTDQ); /* Determine if AVX512_VP2INTERSECT is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_VP2INTERSECT); /* Determine if AVX512_BF16 is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512_BF16); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_BF16); /* Determine if AVX512_FP16 is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AVX512_FP16); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AVX512_FP16); } } } @@ -199,19 +199,19 @@ update_usable (struct cpu_features *cpu_features) == (bit_XTILECFG_state | bit_XTILEDATA_state)) { /* Determine if AMX_BF16 is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AMX_BF16); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AMX_BF16); /* Determine if AMX_TILE is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AMX_TILE); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AMX_TILE); /* Determine if AMX_INT8 is usable. */ - CPU_FEATURE_SET_USABLE (cpu_features, AMX_INT8); + CPU_FEATURE_SET_POSSIBLE (cpu_features, AMX_INT8); } /* These features are usable only when OSXSAVE is enabled. */ CPU_FEATURE_SET (cpu_features, XSAVE); - CPU_FEATURE_SET_USABLE (cpu_features, XSAVEOPT); - CPU_FEATURE_SET_USABLE (cpu_features, XSAVEC); - CPU_FEATURE_SET_USABLE (cpu_features, XGETBV_ECX_1); - CPU_FEATURE_SET_USABLE (cpu_features, XFD); + CPU_FEATURE_SET_POSSIBLE (cpu_features, XSAVEOPT); + CPU_FEATURE_SET_POSSIBLE (cpu_features, XSAVEC); + CPU_FEATURE_SET_POSSIBLE (cpu_features, XGETBV_ECX_1); + CPU_FEATURE_SET_POSSIBLE (cpu_features, XFD); /* For _dl_runtime_resolve, set xsave_state_size to xsave area size + integer register save size and align it to 64 bytes. */ @@ -289,8 +289,8 @@ update_usable (struct cpu_features *cpu_features) if (CPU_FEATURES_CPU_P (cpu_features, AESKLE)) { CPU_FEATURE_SET (cpu_features, AESKLE); - CPU_FEATURE_SET_USABLE (cpu_features, KL); - CPU_FEATURE_SET_USABLE (cpu_features, WIDE_KL); + CPU_FEATURE_SET_POSSIBLE (cpu_features, KL); + CPU_FEATURE_SET_POSSIBLE (cpu_features, WIDE_KL); } cpu_features->isa_1 = get_isa_level (cpu_features); @@ -577,7 +577,7 @@ init_cpu_features (struct cpu_features *cpu_features) { /* Since the FMA4 bit is in CPUID_INDEX_80000001 and FMA4 requires AVX, determine if FMA4 is usable here. */ - CPU_FEATURE_SET_USABLE (cpu_features, FMA4); + CPU_FEATURE_SET_POSSIBLE (cpu_features, FMA4); } if (family == 0x15) diff --git a/sysdeps/x86/dl-diagnostics-cpu.c b/sysdeps/x86/dl-diagnostics-cpu.c index 5d04527ad1..1aa07f8840 100644 --- a/sysdeps/x86/dl-diagnostics-cpu.c +++ b/sysdeps/x86/dl-diagnostics-cpu.c @@ -62,8 +62,8 @@ _dl_diagnostics_cpu (void) cpu_features->features[index].cpuid_array[reg]); for (unsigned int reg = 0; reg < 4; ++reg) print_cpu_feature_internal - (index, "usable", reg, - cpu_features->features[index].usable_array[reg]); + (index, "possible", reg, + cpu_features->features[index].possible_array[reg]); } /* The preferred indicators are not part of the ABI and need to be diff --git a/sysdeps/x86/include/cpu-features.h b/sysdeps/x86/include/cpu-features.h index 59e01df543..4e76bf1f1f 100644 --- a/sysdeps/x86/include/cpu-features.h +++ b/sysdeps/x86/include/cpu-features.h @@ -43,11 +43,11 @@ enum /* Only used directly in cpu-features.c. */ #define CPU_FEATURE_SET(ptr, name) \ - ptr->features[index_cpu_##name].usable.reg_##name |= bit_cpu_##name; + ptr->features[index_cpu_##name].possible.reg_##name |= bit_cpu_##name; #define CPU_FEATURE_UNSET(ptr, name) \ - ptr->features[index_cpu_##name].usable.reg_##name &= ~bit_cpu_##name; -#define CPU_FEATURE_SET_USABLE(ptr, name) \ - ptr->features[index_cpu_##name].usable.reg_##name \ + ptr->features[index_cpu_##name].possible.reg_##name &= ~bit_cpu_##name; +#define CPU_FEATURE_SET_POSSIBLE(ptr, name) \ + ptr->features[index_cpu_##name].possible.reg_##name \ |= ptr->features[index_cpu_##name].cpuid.reg_##name & bit_cpu_##name; #define CPU_FEATURE_PREFERRED_P(ptr, name) \ ((ptr->preferred[index_arch_##name] & bit_arch_##name) != 0) @@ -55,10 +55,14 @@ enum #define CPU_FEATURE_CHECK_P(ptr, name, check) \ ((ptr->features[index_cpu_##name].check.reg_##name \ & bit_cpu_##name) != 0) -#define CPU_FEATURE_CPU_P(ptr, name) \ +#define CPU_FEATURE_PRESENT_P(ptr, name) \ CPU_FEATURE_CHECK_P (ptr, name, cpuid) +#define CPU_FEATURE_POSSIBLE_P(ptr, name) \ + CPU_FEATURE_CHECK_P (ptr, name, possible) +#define CPU_FEATURE_CPU_P(ptr, name) \ + CPU_FEATURE_PRESENT_P (ptr, name) #define CPU_FEATURE_USABLE_P(ptr, name) \ - CPU_FEATURE_CHECK_P (ptr, name, usable) + CPU_FEATURE_POSSIBLE_P (ptr, name) /* HAS_CPU_FEATURE evaluates to true if CPU supports the feature. */ #define HAS_CPU_FEATURE(name) \ @@ -846,8 +850,8 @@ struct cpuid_feature_internal }; union { - unsigned int usable_array[4]; - struct cpuid_registers usable; + unsigned int possible_array[4]; + struct cpuid_registers possible; }; }; diff --git a/sysdeps/x86/sys/platform/x86.h b/sysdeps/x86/sys/platform/x86.h index e930219944..d68429e006 100644 --- a/sysdeps/x86/sys/platform/x86.h +++ b/sysdeps/x86/sys/platform/x86.h @@ -30,7 +30,7 @@ extern const struct cpuid_feature *__x86_get_cpuid_feature_leaf (unsigned int) __attribute__ ((pure)); static __inline__ _Bool -x86_cpu_has_feature (unsigned int __index) +x86_cpu_present (unsigned int __index) { const struct cpuid_feature *__ptr = __x86_get_cpuid_feature_leaf (__index / (8 * sizeof (unsigned int) * 4)); @@ -43,7 +43,7 @@ x86_cpu_has_feature (unsigned int __index) } static __inline__ _Bool -x86_cpu_is_usable (unsigned int __index) +x86_cpu_possible (unsigned int __index) { const struct cpuid_feature *__ptr = __x86_get_cpuid_feature_leaf (__index / (8 * sizeof (unsigned int) * 4)); @@ -52,13 +52,13 @@ x86_cpu_is_usable (unsigned int __index) unsigned int __bit = __reg & (8 * sizeof (unsigned int) - 1); __reg /= 8 * sizeof (unsigned int); - return __ptr->usable_array[__reg] & (1 << __bit); + return __ptr->possible_array[__reg] & (1 << __bit); } -/* HAS_CPU_FEATURE evaluates to true if CPU supports the feature. */ -#define HAS_CPU_FEATURE(name) x86_cpu_has_feature (x86_cpu_##name) -/* CPU_FEATURE_USABLE evaluates to true if the feature is usable. */ -#define CPU_FEATURE_USABLE(name) x86_cpu_is_usable (x86_cpu_##name) +/* CPU_FEATURE_PRESENT evaluates to true if CPU supports the feature. */ +#define CPU_FEATURE_PRESENT(name) x86_cpu_present (x86_cpu_##name) +/* CPU_FEATURE_POSSIBLE evaluates to true if the feature is possible. */ +#define CPU_FEATURE_POSSIBLE(name) x86_cpu_possible (x86_cpu_##name) __END_DECLS diff --git a/sysdeps/x86/tst-cet-legacy-10.c b/sysdeps/x86/tst-cet-legacy-10.c index a618557f45..1cb096e029 100644 --- a/sysdeps/x86/tst-cet-legacy-10.c +++ b/sysdeps/x86/tst-cet-legacy-10.c @@ -1,4 +1,4 @@ -/* Check CPU_FEATURE_USABLE on IBT and SHSTK. +/* Check CPU_FEATURE_POSSIBLE on IBT and SHSTK. Copyright (C) 2021 Free Software Foundation, Inc. This file is part of the GNU C Library. @@ -21,19 +21,19 @@ #include #include -/* Check that CPU_FEATURE_USABLE on IBT and SHSTK matches _get_ssp. */ +/* Check that CPU_FEATURE_POSSIBLE on IBT and SHSTK matches _get_ssp. */ static int do_test (void) { if (_get_ssp () != 0) { - if (CPU_FEATURE_USABLE (IBT) && CPU_FEATURE_USABLE (SHSTK)) + if (CPU_FEATURE_POSSIBLE (IBT) && CPU_FEATURE_POSSIBLE (SHSTK)) return EXIT_SUCCESS; } else { - if (!CPU_FEATURE_USABLE (IBT) && !CPU_FEATURE_USABLE (SHSTK)) + if (!CPU_FEATURE_POSSIBLE (IBT) && !CPU_FEATURE_POSSIBLE (SHSTK)) return EXIT_SUCCESS; } diff --git a/sysdeps/x86/tst-cpu-features-supports.c b/sysdeps/x86/tst-cpu-features-supports.c index 867ea6b8e8..8dc51a1123 100644 --- a/sysdeps/x86/tst-cpu-features-supports.c +++ b/sysdeps/x86/tst-cpu-features-supports.c @@ -37,15 +37,15 @@ check_supports (int supports, int usable, const char *supports_name, return 0; } -#define CHECK_SUPPORTS(str, name) \ +#define CHECK_FEATURE_POSSIBLE(str, name) \ check_supports (__builtin_cpu_supports (#str), \ - CPU_FEATURE_USABLE (name), \ - #str, "CPU_FEATURE_USABLE (" #name ")"); + CPU_FEATURE_POSSIBLE (name), \ + #str, "CPU_FEATURE_POSSIBLE (" #name ")"); -#define CHECK_CPU_SUPPORTS(str, name) \ +#define CHECK_FEATURE_PRESENT(str, name) \ check_supports (__builtin_cpu_supports (#str), \ - HAS_CPU_FEATURE (name), \ - #str, "HAS_CPU_FEATURE (" #name ")"); + CPU_FEATURE_PRESENT (name), \ + #str, "CPU_FEATURE_PRESENT (" #name ")"); static int do_test (int argc, char **argv) @@ -53,140 +53,140 @@ do_test (int argc, char **argv) int fails = 0; #if __GNUC_PREREQ (11, 0) - fails += CHECK_SUPPORTS (adx, ADX); + fails += CHECK_FEATURE_POSSIBLE (adx, ADX); #endif #if __GNUC_PREREQ (6, 0) - fails += CHECK_SUPPORTS (aes, AES); + fails += CHECK_FEATURE_POSSIBLE (aes, AES); #endif #if __GNUC_PREREQ (11, 1) - fails += CHECK_SUPPORTS (amx-bf16, AMX_BF16); - fails += CHECK_SUPPORTS (amx-int8, AMX_INT8); - fails += CHECK_SUPPORTS (amx-tile, AMX_TILE); + fails += CHECK_FEATURE_POSSIBLE (amx-bf16, AMX_BF16); + fails += CHECK_FEATURE_POSSIBLE (amx-int8, AMX_INT8); + fails += CHECK_FEATURE_POSSIBLE (amx-tile, AMX_TILE); #endif - fails += CHECK_SUPPORTS (avx, AVX); - fails += CHECK_SUPPORTS (avx2, AVX2); + fails += CHECK_FEATURE_POSSIBLE (avx, AVX); + fails += CHECK_FEATURE_POSSIBLE (avx2, AVX2); #if __GNUC_PREREQ (7, 0) - fails += CHECK_SUPPORTS (avx5124fmaps, AVX512_4FMAPS); - fails += CHECK_SUPPORTS (avx5124vnniw, AVX512_4VNNIW); + fails += CHECK_FEATURE_POSSIBLE (avx5124fmaps, AVX512_4FMAPS); + fails += CHECK_FEATURE_POSSIBLE (avx5124vnniw, AVX512_4VNNIW); #endif #if __GNUC_PREREQ (10, 0) - fails += CHECK_SUPPORTS (avx512bf16, AVX512_BF16); + fails += CHECK_FEATURE_POSSIBLE (avx512bf16, AVX512_BF16); #endif #if __GNUC_PREREQ (8, 0) - fails += CHECK_SUPPORTS (avx512bitalg, AVX512_BITALG); + fails += CHECK_FEATURE_POSSIBLE (avx512bitalg, AVX512_BITALG); #endif #if __GNUC_PREREQ (6, 0) - fails += CHECK_SUPPORTS (avx512ifma, AVX512_IFMA); - fails += CHECK_SUPPORTS (avx512vbmi, AVX512_VBMI); + fails += CHECK_FEATURE_POSSIBLE (avx512ifma, AVX512_IFMA); + fails += CHECK_FEATURE_POSSIBLE (avx512vbmi, AVX512_VBMI); #endif #if __GNUC_PREREQ (8, 0) - fails += CHECK_SUPPORTS (avx512vbmi2, AVX512_VBMI2); - fails += CHECK_SUPPORTS (avx512vnni, AVX512_VNNI); + fails += CHECK_FEATURE_POSSIBLE (avx512vbmi2, AVX512_VBMI2); + fails += CHECK_FEATURE_POSSIBLE (avx512vnni, AVX512_VNNI); #endif #if __GNUC_PREREQ (10, 0) - fails += CHECK_SUPPORTS (avx512vp2intersect, AVX512_VP2INTERSECT); + fails += CHECK_FEATURE_POSSIBLE (avx512vp2intersect, AVX512_VP2INTERSECT); #endif #if __GNUC_PREREQ (7, 0) - fails += CHECK_SUPPORTS (avx512vpopcntdq, AVX512_VPOPCNTDQ); + fails += CHECK_FEATURE_POSSIBLE (avx512vpopcntdq, AVX512_VPOPCNTDQ); #endif #if __GNUC_PREREQ (6, 0) - fails += CHECK_SUPPORTS (avx512bw, AVX512BW); - fails += CHECK_SUPPORTS (avx512cd, AVX512CD); - fails += CHECK_SUPPORTS (avx512er, AVX512ER); - fails += CHECK_SUPPORTS (avx512dq, AVX512DQ); + fails += CHECK_FEATURE_POSSIBLE (avx512bw, AVX512BW); + fails += CHECK_FEATURE_POSSIBLE (avx512cd, AVX512CD); + fails += CHECK_FEATURE_POSSIBLE (avx512er, AVX512ER); + fails += CHECK_FEATURE_POSSIBLE (avx512dq, AVX512DQ); #endif #if __GNUC_PREREQ (5, 0) - fails += CHECK_SUPPORTS (avx512f, AVX512F); + fails += CHECK_FEATURE_POSSIBLE (avx512f, AVX512F); #endif #if __GNUC_PREREQ (6, 0) - fails += CHECK_SUPPORTS (avx512pf, AVX512PF); - fails += CHECK_SUPPORTS (avx512vl, AVX512VL); + fails += CHECK_FEATURE_POSSIBLE (avx512pf, AVX512PF); + fails += CHECK_FEATURE_POSSIBLE (avx512vl, AVX512VL); #endif #if __GNUC_PREREQ (5, 0) - fails += CHECK_SUPPORTS (bmi, BMI1); - fails += CHECK_SUPPORTS (bmi2, BMI2); + fails += CHECK_FEATURE_POSSIBLE (bmi, BMI1); + fails += CHECK_FEATURE_POSSIBLE (bmi2, BMI2); #endif #if __GNUC_PREREQ (11, 0) - fails += CHECK_SUPPORTS (cldemote, CLDEMOTE); - fails += CHECK_SUPPORTS (clflushopt, CLFLUSHOPT); - fails += CHECK_SUPPORTS (clwb, CLWB); + fails += CHECK_FEATURE_POSSIBLE (cldemote, CLDEMOTE); + fails += CHECK_FEATURE_POSSIBLE (clflushopt, CLFLUSHOPT); + fails += CHECK_FEATURE_POSSIBLE (clwb, CLWB); #endif - fails += CHECK_SUPPORTS (cmov, CMOV); + fails += CHECK_FEATURE_POSSIBLE (cmov, CMOV); #if __GNUC_PREREQ (11, 0) - fails += CHECK_SUPPORTS (cmpxchg16b, CMPXCHG16B); - fails += CHECK_SUPPORTS (cmpxchg8b, CX8); - fails += CHECK_SUPPORTS (enqcmd, ENQCMD); - fails += CHECK_SUPPORTS (f16c, F16C); + fails += CHECK_FEATURE_POSSIBLE (cmpxchg16b, CMPXCHG16B); + fails += CHECK_FEATURE_POSSIBLE (cmpxchg8b, CX8); + fails += CHECK_FEATURE_POSSIBLE (enqcmd, ENQCMD); + fails += CHECK_FEATURE_POSSIBLE (f16c, F16C); #endif #if __GNUC_PREREQ (4, 9) - fails += CHECK_SUPPORTS (fma, FMA); - fails += CHECK_SUPPORTS (fma4, FMA4); + fails += CHECK_FEATURE_POSSIBLE (fma, FMA); + fails += CHECK_FEATURE_POSSIBLE (fma4, FMA4); #endif #if __GNUC_PREREQ (11, 0) - fails += CHECK_CPU_SUPPORTS (fsgsbase, FSGSBASE); - fails += CHECK_SUPPORTS (fxsave, FXSR); + fails += CHECK_FEATURE_PRESENT (fsgsbase, FSGSBASE); + fails += CHECK_FEATURE_POSSIBLE (fxsave, FXSR); #endif #if __GNUC_PREREQ (8, 0) - fails += CHECK_SUPPORTS (gfni, GFNI); + fails += CHECK_FEATURE_POSSIBLE (gfni, GFNI); #endif #if __GNUC_PREREQ (11, 0) - fails += CHECK_SUPPORTS (hle, HLE); - fails += CHECK_CPU_SUPPORTS (ibt, IBT); - fails += CHECK_SUPPORTS (lahf_lm, LAHF64_SAHF64); - fails += CHECK_CPU_SUPPORTS (lm, LM); - fails += CHECK_SUPPORTS (lwp, LWP); - fails += CHECK_SUPPORTS (lzcnt, LZCNT); -#endif - fails += CHECK_SUPPORTS (mmx, MMX); + fails += CHECK_FEATURE_POSSIBLE (hle, HLE); + fails += CHECK_FEATURE_PRESENT (ibt, IBT); + fails += CHECK_FEATURE_POSSIBLE (lahf_lm, LAHF64_SAHF64); + fails += CHECK_FEATURE_PRESENT (lm, LM); + fails += CHECK_FEATURE_POSSIBLE (lwp, LWP); + fails += CHECK_FEATURE_POSSIBLE (lzcnt, LZCNT); +#endif + fails += CHECK_FEATURE_POSSIBLE (mmx, MMX); #if __GNUC_PREREQ (11, 0) - fails += CHECK_SUPPORTS (movbe, MOVBE); - fails += CHECK_SUPPORTS (movdiri, MOVDIRI); - fails += CHECK_SUPPORTS (movdir64b, MOVDIR64B); - fails += CHECK_SUPPORTS (osxsave, OSXSAVE); - fails += CHECK_SUPPORTS (pconfig, PCONFIG); - fails += CHECK_SUPPORTS (pku, PKU); -#endif - fails += CHECK_SUPPORTS (popcnt, POPCNT); + fails += CHECK_FEATURE_POSSIBLE (movbe, MOVBE); + fails += CHECK_FEATURE_POSSIBLE (movdiri, MOVDIRI); + fails += CHECK_FEATURE_POSSIBLE (movdir64b, MOVDIR64B); + fails += CHECK_FEATURE_POSSIBLE (osxsave, OSXSAVE); + fails += CHECK_FEATURE_POSSIBLE (pconfig, PCONFIG); + fails += CHECK_FEATURE_POSSIBLE (pku, PKU); +#endif + fails += CHECK_FEATURE_POSSIBLE (popcnt, POPCNT); #if __GNUC_PREREQ (11, 0) - fails += CHECK_SUPPORTS (prefetchwt1, PREFETCHWT1); - fails += CHECK_SUPPORTS (ptwrite, PTWRITE); - fails += CHECK_SUPPORTS (rdpid, RDPID); - fails += CHECK_SUPPORTS (rdrnd, RDRAND); - fails += CHECK_SUPPORTS (rdseed, RDSEED); - fails += CHECK_CPU_SUPPORTS (rtm, RTM); - fails += CHECK_SUPPORTS (serialize, SERIALIZE); - fails += CHECK_SUPPORTS (sha, SHA); - fails += CHECK_CPU_SUPPORTS (shstk, SHSTK); -#endif - fails += CHECK_SUPPORTS (sse, SSE); - fails += CHECK_SUPPORTS (sse2, SSE2); - fails += CHECK_SUPPORTS (sse3, SSE3); - fails += CHECK_SUPPORTS (sse4.1, SSE4_1); - fails += CHECK_SUPPORTS (sse4.2, SSE4_2); + fails += CHECK_FEATURE_POSSIBLE (prefetchwt1, PREFETCHWT1); + fails += CHECK_FEATURE_POSSIBLE (ptwrite, PTWRITE); + fails += CHECK_FEATURE_POSSIBLE (rdpid, RDPID); + fails += CHECK_FEATURE_POSSIBLE (rdrnd, RDRAND); + fails += CHECK_FEATURE_POSSIBLE (rdseed, RDSEED); + fails += CHECK_FEATURE_PRESENT (rtm, RTM); + fails += CHECK_FEATURE_POSSIBLE (serialize, SERIALIZE); + fails += CHECK_FEATURE_POSSIBLE (sha, SHA); + fails += CHECK_FEATURE_PRESENT (shstk, SHSTK); +#endif + fails += CHECK_FEATURE_POSSIBLE (sse, SSE); + fails += CHECK_FEATURE_POSSIBLE (sse2, SSE2); + fails += CHECK_FEATURE_POSSIBLE (sse3, SSE3); + fails += CHECK_FEATURE_POSSIBLE (sse4.1, SSE4_1); + fails += CHECK_FEATURE_POSSIBLE (sse4.2, SSE4_2); #if __GNUC_PREREQ (4, 9) - fails += CHECK_SUPPORTS (sse4a, SSE4A); + fails += CHECK_FEATURE_POSSIBLE (sse4a, SSE4A); #endif - fails += CHECK_SUPPORTS (ssse3, SSSE3); + fails += CHECK_FEATURE_POSSIBLE (ssse3, SSSE3); #if __GNUC_PREREQ (11, 0) - fails += CHECK_SUPPORTS (tbm, TBM); - fails += CHECK_SUPPORTS (tsxldtrk, TSXLDTRK); - fails += CHECK_SUPPORTS (vaes, VAES); + fails += CHECK_FEATURE_POSSIBLE (tbm, TBM); + fails += CHECK_FEATURE_POSSIBLE (tsxldtrk, TSXLDTRK); + fails += CHECK_FEATURE_POSSIBLE (vaes, VAES); #endif #if __GNUC_PREREQ (8, 0) - fails += CHECK_SUPPORTS (vpclmulqdq, VPCLMULQDQ); + fails += CHECK_FEATURE_POSSIBLE (vpclmulqdq, VPCLMULQDQ); #endif #if __GNUC_PREREQ (11, 0) - fails += CHECK_SUPPORTS (waitpkg, WAITPKG); - fails += CHECK_SUPPORTS (wbnoinvd, WBNOINVD); + fails += CHECK_FEATURE_POSSIBLE (waitpkg, WAITPKG); + fails += CHECK_FEATURE_POSSIBLE (wbnoinvd, WBNOINVD); #endif #if __GNUC_PREREQ (4, 9) - fails += CHECK_SUPPORTS (xop, XOP); + fails += CHECK_FEATURE_POSSIBLE (xop, XOP); #endif #if __GNUC_PREREQ (11, 0) - fails += CHECK_SUPPORTS (xsave, XSAVE); - fails += CHECK_SUPPORTS (xsavec, XSAVEC); - fails += CHECK_SUPPORTS (xsaveopt, XSAVEOPT); - fails += CHECK_CPU_SUPPORTS (xsaves, XSAVES); + fails += CHECK_FEATURE_POSSIBLE (xsave, XSAVE); + fails += CHECK_FEATURE_POSSIBLE (xsavec, XSAVEC); + fails += CHECK_FEATURE_POSSIBLE (xsaveopt, XSAVEOPT); + fails += CHECK_FEATURE_PRESENT (xsaves, XSAVES); #endif printf ("%d differences between __builtin_cpu_supports and glibc code.\n", diff --git a/sysdeps/x86/tst-get-cpu-features.c b/sysdeps/x86/tst-get-cpu-features.c index 11fa3054b9..3ca39b5275 100644 --- a/sysdeps/x86/tst-get-cpu-features.c +++ b/sysdeps/x86/tst-get-cpu-features.c @@ -21,353 +21,353 @@ #include #include -#define CHECK_CPU_FEATURE(name) \ - { \ - if (HAS_CPU_FEATURE (name)) \ - printf (" " #name "\n"); \ +#define CHECK_CPU_FEATURE_PRESENT(name) \ + { \ + if (CPU_FEATURE_PRESENT (name)) \ + printf (" " #name "\n"); \ } -#define CHECK_CPU_FEATURE_USABLE(name) \ - { \ - if (CPU_FEATURE_USABLE(name)) \ - printf (" " #name "\n"); \ +#define CHECK_CPU_FEATURE_POSSIBLE(name) \ + { \ + if (CPU_FEATURE_POSSIBLE(name)) \ + printf (" " #name "\n"); \ } static int do_test (void) { #ifdef __SSE2__ - TEST_VERIFY_EXIT (HAS_CPU_FEATURE (SSE2)); + TEST_VERIFY_EXIT (CPU_FEATURE_PRESENT (SSE2)); #endif printf ("CPU features:\n"); - CHECK_CPU_FEATURE (SSE3); - CHECK_CPU_FEATURE (PCLMULQDQ); - CHECK_CPU_FEATURE (DTES64); - CHECK_CPU_FEATURE (MONITOR); - CHECK_CPU_FEATURE (DS_CPL); - CHECK_CPU_FEATURE (VMX); - CHECK_CPU_FEATURE (SMX); - CHECK_CPU_FEATURE (EIST); - CHECK_CPU_FEATURE (TM2); - CHECK_CPU_FEATURE (SSSE3); - CHECK_CPU_FEATURE (CNXT_ID); - CHECK_CPU_FEATURE (SDBG); - CHECK_CPU_FEATURE (FMA); - CHECK_CPU_FEATURE (CMPXCHG16B); - CHECK_CPU_FEATURE (XTPRUPDCTRL); - CHECK_CPU_FEATURE (PDCM); - CHECK_CPU_FEATURE (PCID); - CHECK_CPU_FEATURE (DCA); - CHECK_CPU_FEATURE (SSE4_1); - CHECK_CPU_FEATURE (SSE4_2); - CHECK_CPU_FEATURE (X2APIC); - CHECK_CPU_FEATURE (MOVBE); - CHECK_CPU_FEATURE (POPCNT); - CHECK_CPU_FEATURE (TSC_DEADLINE); - CHECK_CPU_FEATURE (AES); - CHECK_CPU_FEATURE (XSAVE); - CHECK_CPU_FEATURE (OSXSAVE); - CHECK_CPU_FEATURE (AVX); - CHECK_CPU_FEATURE (F16C); - CHECK_CPU_FEATURE (RDRAND); - CHECK_CPU_FEATURE (FPU); - CHECK_CPU_FEATURE (VME); - CHECK_CPU_FEATURE (DE); - CHECK_CPU_FEATURE (PSE); - CHECK_CPU_FEATURE (TSC); - CHECK_CPU_FEATURE (MSR); - CHECK_CPU_FEATURE (PAE); - CHECK_CPU_FEATURE (MCE); - CHECK_CPU_FEATURE (CX8); - CHECK_CPU_FEATURE (APIC); - CHECK_CPU_FEATURE (SEP); - CHECK_CPU_FEATURE (MTRR); - CHECK_CPU_FEATURE (PGE); - CHECK_CPU_FEATURE (MCA); - CHECK_CPU_FEATURE (CMOV); - CHECK_CPU_FEATURE (PAT); - CHECK_CPU_FEATURE (PSE_36); - CHECK_CPU_FEATURE (PSN); - CHECK_CPU_FEATURE (CLFSH); - CHECK_CPU_FEATURE (DS); - CHECK_CPU_FEATURE (ACPI); - CHECK_CPU_FEATURE (MMX); - CHECK_CPU_FEATURE (FXSR); - CHECK_CPU_FEATURE (SSE); - CHECK_CPU_FEATURE (SSE2); - CHECK_CPU_FEATURE (SS); - CHECK_CPU_FEATURE (HTT); - CHECK_CPU_FEATURE (TM); - CHECK_CPU_FEATURE (PBE); - CHECK_CPU_FEATURE (FSGSBASE); - CHECK_CPU_FEATURE (TSC_ADJUST); - CHECK_CPU_FEATURE (SGX); - CHECK_CPU_FEATURE (BMI1); - CHECK_CPU_FEATURE (HLE); - CHECK_CPU_FEATURE (AVX2); - CHECK_CPU_FEATURE (SMEP); - CHECK_CPU_FEATURE (BMI2); - CHECK_CPU_FEATURE (ERMS); - CHECK_CPU_FEATURE (INVPCID); - CHECK_CPU_FEATURE (RTM); - CHECK_CPU_FEATURE (RDT_M); - CHECK_CPU_FEATURE (DEPR_FPU_CS_DS); - CHECK_CPU_FEATURE (MPX); - CHECK_CPU_FEATURE (RDT_A); - CHECK_CPU_FEATURE (AVX512F); - CHECK_CPU_FEATURE (AVX512DQ); - CHECK_CPU_FEATURE (RDSEED); - CHECK_CPU_FEATURE (ADX); - CHECK_CPU_FEATURE (SMAP); - CHECK_CPU_FEATURE (AVX512_IFMA); - CHECK_CPU_FEATURE (CLFLUSHOPT); - CHECK_CPU_FEATURE (CLWB); - CHECK_CPU_FEATURE (TRACE); - CHECK_CPU_FEATURE (AVX512PF); - CHECK_CPU_FEATURE (AVX512ER); - CHECK_CPU_FEATURE (AVX512CD); - CHECK_CPU_FEATURE (SHA); - CHECK_CPU_FEATURE (AVX512BW); - CHECK_CPU_FEATURE (AVX512VL); - CHECK_CPU_FEATURE (PREFETCHWT1); - CHECK_CPU_FEATURE (AVX512_VBMI); - CHECK_CPU_FEATURE (UMIP); - CHECK_CPU_FEATURE (PKU); - CHECK_CPU_FEATURE (OSPKE); - CHECK_CPU_FEATURE (WAITPKG); - CHECK_CPU_FEATURE (AVX512_VBMI2); - CHECK_CPU_FEATURE (SHSTK); - CHECK_CPU_FEATURE (GFNI); - CHECK_CPU_FEATURE (VAES); - CHECK_CPU_FEATURE (VPCLMULQDQ); - CHECK_CPU_FEATURE (AVX512_VNNI); - CHECK_CPU_FEATURE (AVX512_BITALG); - CHECK_CPU_FEATURE (AVX512_VPOPCNTDQ); - CHECK_CPU_FEATURE (RDPID); - CHECK_CPU_FEATURE (KL); - CHECK_CPU_FEATURE (CLDEMOTE); - CHECK_CPU_FEATURE (MOVDIRI); - CHECK_CPU_FEATURE (MOVDIR64B); - CHECK_CPU_FEATURE (ENQCMD); - CHECK_CPU_FEATURE (SGX_LC); - CHECK_CPU_FEATURE (PKS); - CHECK_CPU_FEATURE (AVX512_4VNNIW); - CHECK_CPU_FEATURE (AVX512_4FMAPS); - CHECK_CPU_FEATURE (FSRM); - CHECK_CPU_FEATURE (UINTR); - CHECK_CPU_FEATURE (AVX512_VP2INTERSECT); - CHECK_CPU_FEATURE (MD_CLEAR); - CHECK_CPU_FEATURE (RTM_ALWAYS_ABORT); - CHECK_CPU_FEATURE (SERIALIZE); - CHECK_CPU_FEATURE (HYBRID); - CHECK_CPU_FEATURE (TSXLDTRK); - CHECK_CPU_FEATURE (PCONFIG); - CHECK_CPU_FEATURE (IBT); - CHECK_CPU_FEATURE (AMX_BF16); - CHECK_CPU_FEATURE (AVX512_FP16); - CHECK_CPU_FEATURE (AMX_TILE); - CHECK_CPU_FEATURE (AMX_INT8); - CHECK_CPU_FEATURE (IBRS_IBPB); - CHECK_CPU_FEATURE (STIBP); - CHECK_CPU_FEATURE (L1D_FLUSH); - CHECK_CPU_FEATURE (ARCH_CAPABILITIES); - CHECK_CPU_FEATURE (CORE_CAPABILITIES); - CHECK_CPU_FEATURE (SSBD); - CHECK_CPU_FEATURE (LAHF64_SAHF64); - CHECK_CPU_FEATURE (SVM); - CHECK_CPU_FEATURE (LZCNT); - CHECK_CPU_FEATURE (SSE4A); - CHECK_CPU_FEATURE (PREFETCHW); - CHECK_CPU_FEATURE (XOP); - CHECK_CPU_FEATURE (LWP); - CHECK_CPU_FEATURE (FMA4); - CHECK_CPU_FEATURE (TBM); - CHECK_CPU_FEATURE (SYSCALL_SYSRET); - CHECK_CPU_FEATURE (NX); - CHECK_CPU_FEATURE (PAGE1GB); - CHECK_CPU_FEATURE (RDTSCP); - CHECK_CPU_FEATURE (LM); - CHECK_CPU_FEATURE (XSAVEOPT); - CHECK_CPU_FEATURE (XSAVEC); - CHECK_CPU_FEATURE (XGETBV_ECX_1); - CHECK_CPU_FEATURE (XSAVES); - CHECK_CPU_FEATURE (XFD); - CHECK_CPU_FEATURE (INVARIANT_TSC); - CHECK_CPU_FEATURE (WBNOINVD); - CHECK_CPU_FEATURE (AVX_VNNI); - CHECK_CPU_FEATURE (AVX512_BF16); - CHECK_CPU_FEATURE (FZLRM); - CHECK_CPU_FEATURE (FSRS); - CHECK_CPU_FEATURE (FSRCS); - CHECK_CPU_FEATURE (HRESET); - CHECK_CPU_FEATURE (LAM); - CHECK_CPU_FEATURE (AESKLE); - CHECK_CPU_FEATURE (WIDE_KL); - CHECK_CPU_FEATURE (PTWRITE); + CHECK_CPU_FEATURE_PRESENT (SSE3); + CHECK_CPU_FEATURE_PRESENT (PCLMULQDQ); + CHECK_CPU_FEATURE_PRESENT (DTES64); + CHECK_CPU_FEATURE_PRESENT (MONITOR); + CHECK_CPU_FEATURE_PRESENT (DS_CPL); + CHECK_CPU_FEATURE_PRESENT (VMX); + CHECK_CPU_FEATURE_PRESENT (SMX); + CHECK_CPU_FEATURE_PRESENT (EIST); + CHECK_CPU_FEATURE_PRESENT (TM2); + CHECK_CPU_FEATURE_PRESENT (SSSE3); + CHECK_CPU_FEATURE_PRESENT (CNXT_ID); + CHECK_CPU_FEATURE_PRESENT (SDBG); + CHECK_CPU_FEATURE_PRESENT (FMA); + CHECK_CPU_FEATURE_PRESENT (CMPXCHG16B); + CHECK_CPU_FEATURE_PRESENT (XTPRUPDCTRL); + CHECK_CPU_FEATURE_PRESENT (PDCM); + CHECK_CPU_FEATURE_PRESENT (PCID); + CHECK_CPU_FEATURE_PRESENT (DCA); + CHECK_CPU_FEATURE_PRESENT (SSE4_1); + CHECK_CPU_FEATURE_PRESENT (SSE4_2); + CHECK_CPU_FEATURE_PRESENT (X2APIC); + CHECK_CPU_FEATURE_PRESENT (MOVBE); + CHECK_CPU_FEATURE_PRESENT (POPCNT); + CHECK_CPU_FEATURE_PRESENT (TSC_DEADLINE); + CHECK_CPU_FEATURE_PRESENT (AES); + CHECK_CPU_FEATURE_PRESENT (XSAVE); + CHECK_CPU_FEATURE_PRESENT (OSXSAVE); + CHECK_CPU_FEATURE_PRESENT (AVX); + CHECK_CPU_FEATURE_PRESENT (F16C); + CHECK_CPU_FEATURE_PRESENT (RDRAND); + CHECK_CPU_FEATURE_PRESENT (FPU); + CHECK_CPU_FEATURE_PRESENT (VME); + CHECK_CPU_FEATURE_PRESENT (DE); + CHECK_CPU_FEATURE_PRESENT (PSE); + CHECK_CPU_FEATURE_PRESENT (TSC); + CHECK_CPU_FEATURE_PRESENT (MSR); + CHECK_CPU_FEATURE_PRESENT (PAE); + CHECK_CPU_FEATURE_PRESENT (MCE); + CHECK_CPU_FEATURE_PRESENT (CX8); + CHECK_CPU_FEATURE_PRESENT (APIC); + CHECK_CPU_FEATURE_PRESENT (SEP); + CHECK_CPU_FEATURE_PRESENT (MTRR); + CHECK_CPU_FEATURE_PRESENT (PGE); + CHECK_CPU_FEATURE_PRESENT (MCA); + CHECK_CPU_FEATURE_PRESENT (CMOV); + CHECK_CPU_FEATURE_PRESENT (PAT); + CHECK_CPU_FEATURE_PRESENT (PSE_36); + CHECK_CPU_FEATURE_PRESENT (PSN); + CHECK_CPU_FEATURE_PRESENT (CLFSH); + CHECK_CPU_FEATURE_PRESENT (DS); + CHECK_CPU_FEATURE_PRESENT (ACPI); + CHECK_CPU_FEATURE_PRESENT (MMX); + CHECK_CPU_FEATURE_PRESENT (FXSR); + CHECK_CPU_FEATURE_PRESENT (SSE); + CHECK_CPU_FEATURE_PRESENT (SSE2); + CHECK_CPU_FEATURE_PRESENT (SS); + CHECK_CPU_FEATURE_PRESENT (HTT); + CHECK_CPU_FEATURE_PRESENT (TM); + CHECK_CPU_FEATURE_PRESENT (PBE); + CHECK_CPU_FEATURE_PRESENT (FSGSBASE); + CHECK_CPU_FEATURE_PRESENT (TSC_ADJUST); + CHECK_CPU_FEATURE_PRESENT (SGX); + CHECK_CPU_FEATURE_PRESENT (BMI1); + CHECK_CPU_FEATURE_PRESENT (HLE); + CHECK_CPU_FEATURE_PRESENT (AVX2); + CHECK_CPU_FEATURE_PRESENT (SMEP); + CHECK_CPU_FEATURE_PRESENT (BMI2); + CHECK_CPU_FEATURE_PRESENT (ERMS); + CHECK_CPU_FEATURE_PRESENT (INVPCID); + CHECK_CPU_FEATURE_PRESENT (RTM); + CHECK_CPU_FEATURE_PRESENT (RDT_M); + CHECK_CPU_FEATURE_PRESENT (DEPR_FPU_CS_DS); + CHECK_CPU_FEATURE_PRESENT (MPX); + CHECK_CPU_FEATURE_PRESENT (RDT_A); + CHECK_CPU_FEATURE_PRESENT (AVX512F); + CHECK_CPU_FEATURE_PRESENT (AVX512DQ); + CHECK_CPU_FEATURE_PRESENT (RDSEED); + CHECK_CPU_FEATURE_PRESENT (ADX); + CHECK_CPU_FEATURE_PRESENT (SMAP); + CHECK_CPU_FEATURE_PRESENT (AVX512_IFMA); + CHECK_CPU_FEATURE_PRESENT (CLFLUSHOPT); + CHECK_CPU_FEATURE_PRESENT (CLWB); + CHECK_CPU_FEATURE_PRESENT (TRACE); + CHECK_CPU_FEATURE_PRESENT (AVX512PF); + CHECK_CPU_FEATURE_PRESENT (AVX512ER); + CHECK_CPU_FEATURE_PRESENT (AVX512CD); + CHECK_CPU_FEATURE_PRESENT (SHA); + CHECK_CPU_FEATURE_PRESENT (AVX512BW); + CHECK_CPU_FEATURE_PRESENT (AVX512VL); + CHECK_CPU_FEATURE_PRESENT (PREFETCHWT1); + CHECK_CPU_FEATURE_PRESENT (AVX512_VBMI); + CHECK_CPU_FEATURE_PRESENT (UMIP); + CHECK_CPU_FEATURE_PRESENT (PKU); + CHECK_CPU_FEATURE_PRESENT (OSPKE); + CHECK_CPU_FEATURE_PRESENT (WAITPKG); + CHECK_CPU_FEATURE_PRESENT (AVX512_VBMI2); + CHECK_CPU_FEATURE_PRESENT (SHSTK); + CHECK_CPU_FEATURE_PRESENT (GFNI); + CHECK_CPU_FEATURE_PRESENT (VAES); + CHECK_CPU_FEATURE_PRESENT (VPCLMULQDQ); + CHECK_CPU_FEATURE_PRESENT (AVX512_VNNI); + CHECK_CPU_FEATURE_PRESENT (AVX512_BITALG); + CHECK_CPU_FEATURE_PRESENT (AVX512_VPOPCNTDQ); + CHECK_CPU_FEATURE_PRESENT (RDPID); + CHECK_CPU_FEATURE_PRESENT (KL); + CHECK_CPU_FEATURE_PRESENT (CLDEMOTE); + CHECK_CPU_FEATURE_PRESENT (MOVDIRI); + CHECK_CPU_FEATURE_PRESENT (MOVDIR64B); + CHECK_CPU_FEATURE_PRESENT (ENQCMD); + CHECK_CPU_FEATURE_PRESENT (SGX_LC); + CHECK_CPU_FEATURE_PRESENT (PKS); + CHECK_CPU_FEATURE_PRESENT (AVX512_4VNNIW); + CHECK_CPU_FEATURE_PRESENT (AVX512_4FMAPS); + CHECK_CPU_FEATURE_PRESENT (FSRM); + CHECK_CPU_FEATURE_PRESENT (UINTR); + CHECK_CPU_FEATURE_PRESENT (AVX512_VP2INTERSECT); + CHECK_CPU_FEATURE_PRESENT (MD_CLEAR); + CHECK_CPU_FEATURE_PRESENT (RTM_ALWAYS_ABORT); + CHECK_CPU_FEATURE_PRESENT (SERIALIZE); + CHECK_CPU_FEATURE_PRESENT (HYBRID); + CHECK_CPU_FEATURE_PRESENT (TSXLDTRK); + CHECK_CPU_FEATURE_PRESENT (PCONFIG); + CHECK_CPU_FEATURE_PRESENT (IBT); + CHECK_CPU_FEATURE_PRESENT (AMX_BF16); + CHECK_CPU_FEATURE_PRESENT (AVX512_FP16); + CHECK_CPU_FEATURE_PRESENT (AMX_TILE); + CHECK_CPU_FEATURE_PRESENT (AMX_INT8); + CHECK_CPU_FEATURE_PRESENT (IBRS_IBPB); + CHECK_CPU_FEATURE_PRESENT (STIBP); + CHECK_CPU_FEATURE_PRESENT (L1D_FLUSH); + CHECK_CPU_FEATURE_PRESENT (ARCH_CAPABILITIES); + CHECK_CPU_FEATURE_PRESENT (CORE_CAPABILITIES); + CHECK_CPU_FEATURE_PRESENT (SSBD); + CHECK_CPU_FEATURE_PRESENT (LAHF64_SAHF64); + CHECK_CPU_FEATURE_PRESENT (SVM); + CHECK_CPU_FEATURE_PRESENT (LZCNT); + CHECK_CPU_FEATURE_PRESENT (SSE4A); + CHECK_CPU_FEATURE_PRESENT (PREFETCHW); + CHECK_CPU_FEATURE_PRESENT (XOP); + CHECK_CPU_FEATURE_PRESENT (LWP); + CHECK_CPU_FEATURE_PRESENT (FMA4); + CHECK_CPU_FEATURE_PRESENT (TBM); + CHECK_CPU_FEATURE_PRESENT (SYSCALL_SYSRET); + CHECK_CPU_FEATURE_PRESENT (NX); + CHECK_CPU_FEATURE_PRESENT (PAGE1GB); + CHECK_CPU_FEATURE_PRESENT (RDTSCP); + CHECK_CPU_FEATURE_PRESENT (LM); + CHECK_CPU_FEATURE_PRESENT (XSAVEOPT); + CHECK_CPU_FEATURE_PRESENT (XSAVEC); + CHECK_CPU_FEATURE_PRESENT (XGETBV_ECX_1); + CHECK_CPU_FEATURE_PRESENT (XSAVES); + CHECK_CPU_FEATURE_PRESENT (XFD); + CHECK_CPU_FEATURE_PRESENT (INVARIANT_TSC); + CHECK_CPU_FEATURE_PRESENT (WBNOINVD); + CHECK_CPU_FEATURE_PRESENT (AVX_VNNI); + CHECK_CPU_FEATURE_PRESENT (AVX512_BF16); + CHECK_CPU_FEATURE_PRESENT (FZLRM); + CHECK_CPU_FEATURE_PRESENT (FSRS); + CHECK_CPU_FEATURE_PRESENT (FSRCS); + CHECK_CPU_FEATURE_PRESENT (HRESET); + CHECK_CPU_FEATURE_PRESENT (LAM); + CHECK_CPU_FEATURE_PRESENT (AESKLE); + CHECK_CPU_FEATURE_PRESENT (WIDE_KL); + CHECK_CPU_FEATURE_PRESENT (PTWRITE); - printf ("Usable CPU features:\n"); - CHECK_CPU_FEATURE_USABLE (SSE3); - CHECK_CPU_FEATURE_USABLE (PCLMULQDQ); - CHECK_CPU_FEATURE_USABLE (DTES64); - CHECK_CPU_FEATURE_USABLE (MONITOR); - CHECK_CPU_FEATURE_USABLE (DS_CPL); - CHECK_CPU_FEATURE_USABLE (VMX); - CHECK_CPU_FEATURE_USABLE (SMX); - CHECK_CPU_FEATURE_USABLE (EIST); - CHECK_CPU_FEATURE_USABLE (TM2); - CHECK_CPU_FEATURE_USABLE (SSSE3); - CHECK_CPU_FEATURE_USABLE (CNXT_ID); - CHECK_CPU_FEATURE_USABLE (SDBG); - CHECK_CPU_FEATURE_USABLE (FMA); - CHECK_CPU_FEATURE_USABLE (CMPXCHG16B); - CHECK_CPU_FEATURE_USABLE (XTPRUPDCTRL); - CHECK_CPU_FEATURE_USABLE (PDCM); - CHECK_CPU_FEATURE_USABLE (PCID); - CHECK_CPU_FEATURE_USABLE (DCA); - CHECK_CPU_FEATURE_USABLE (SSE4_1); - CHECK_CPU_FEATURE_USABLE (SSE4_2); - CHECK_CPU_FEATURE_USABLE (X2APIC); - CHECK_CPU_FEATURE_USABLE (MOVBE); - CHECK_CPU_FEATURE_USABLE (POPCNT); - CHECK_CPU_FEATURE_USABLE (TSC_DEADLINE); - CHECK_CPU_FEATURE_USABLE (AES); - CHECK_CPU_FEATURE_USABLE (XSAVE); - CHECK_CPU_FEATURE_USABLE (OSXSAVE); - CHECK_CPU_FEATURE_USABLE (AVX); - CHECK_CPU_FEATURE_USABLE (F16C); - CHECK_CPU_FEATURE_USABLE (RDRAND); - CHECK_CPU_FEATURE_USABLE (FPU); - CHECK_CPU_FEATURE_USABLE (VME); - CHECK_CPU_FEATURE_USABLE (DE); - CHECK_CPU_FEATURE_USABLE (PSE); - CHECK_CPU_FEATURE_USABLE (TSC); - CHECK_CPU_FEATURE_USABLE (MSR); - CHECK_CPU_FEATURE_USABLE (PAE); - CHECK_CPU_FEATURE_USABLE (MCE); - CHECK_CPU_FEATURE_USABLE (CX8); - CHECK_CPU_FEATURE_USABLE (APIC); - CHECK_CPU_FEATURE_USABLE (SEP); - CHECK_CPU_FEATURE_USABLE (MTRR); - CHECK_CPU_FEATURE_USABLE (PGE); - CHECK_CPU_FEATURE_USABLE (MCA); - CHECK_CPU_FEATURE_USABLE (CMOV); - CHECK_CPU_FEATURE_USABLE (PAT); - CHECK_CPU_FEATURE_USABLE (PSE_36); - CHECK_CPU_FEATURE_USABLE (PSN); - CHECK_CPU_FEATURE_USABLE (CLFSH); - CHECK_CPU_FEATURE_USABLE (DS); - CHECK_CPU_FEATURE_USABLE (ACPI); - CHECK_CPU_FEATURE_USABLE (MMX); - CHECK_CPU_FEATURE_USABLE (FXSR); - CHECK_CPU_FEATURE_USABLE (SSE); - CHECK_CPU_FEATURE_USABLE (SSE2); - CHECK_CPU_FEATURE_USABLE (SS); - CHECK_CPU_FEATURE_USABLE (HTT); - CHECK_CPU_FEATURE_USABLE (TM); - CHECK_CPU_FEATURE_USABLE (PBE); - CHECK_CPU_FEATURE_USABLE (FSGSBASE); - CHECK_CPU_FEATURE_USABLE (TSC_ADJUST); - CHECK_CPU_FEATURE_USABLE (SGX); - CHECK_CPU_FEATURE_USABLE (BMI1); - CHECK_CPU_FEATURE_USABLE (HLE); - CHECK_CPU_FEATURE_USABLE (AVX2); - CHECK_CPU_FEATURE_USABLE (SMEP); - CHECK_CPU_FEATURE_USABLE (BMI2); - CHECK_CPU_FEATURE_USABLE (ERMS); - CHECK_CPU_FEATURE_USABLE (INVPCID); - CHECK_CPU_FEATURE_USABLE (RTM); - CHECK_CPU_FEATURE_USABLE (RDT_M); - CHECK_CPU_FEATURE_USABLE (DEPR_FPU_CS_DS); - CHECK_CPU_FEATURE_USABLE (MPX); - CHECK_CPU_FEATURE_USABLE (RDT_A); - CHECK_CPU_FEATURE_USABLE (AVX512F); - CHECK_CPU_FEATURE_USABLE (AVX512DQ); - CHECK_CPU_FEATURE_USABLE (RDSEED); - CHECK_CPU_FEATURE_USABLE (ADX); - CHECK_CPU_FEATURE_USABLE (SMAP); - CHECK_CPU_FEATURE_USABLE (AVX512_IFMA); - CHECK_CPU_FEATURE_USABLE (CLFLUSHOPT); - CHECK_CPU_FEATURE_USABLE (CLWB); - CHECK_CPU_FEATURE_USABLE (TRACE); - CHECK_CPU_FEATURE_USABLE (AVX512PF); - CHECK_CPU_FEATURE_USABLE (AVX512ER); - CHECK_CPU_FEATURE_USABLE (AVX512CD); - CHECK_CPU_FEATURE_USABLE (SHA); - CHECK_CPU_FEATURE_USABLE (AVX512BW); - CHECK_CPU_FEATURE_USABLE (AVX512VL); - CHECK_CPU_FEATURE_USABLE (PREFETCHWT1); - CHECK_CPU_FEATURE_USABLE (AVX512_VBMI); - CHECK_CPU_FEATURE_USABLE (UMIP); - CHECK_CPU_FEATURE_USABLE (PKU); - CHECK_CPU_FEATURE_USABLE (OSPKE); - CHECK_CPU_FEATURE_USABLE (WAITPKG); - CHECK_CPU_FEATURE_USABLE (AVX512_VBMI2); - CHECK_CPU_FEATURE_USABLE (SHSTK); - CHECK_CPU_FEATURE_USABLE (GFNI); - CHECK_CPU_FEATURE_USABLE (VAES); - CHECK_CPU_FEATURE_USABLE (VPCLMULQDQ); - CHECK_CPU_FEATURE_USABLE (AVX512_VNNI); - CHECK_CPU_FEATURE_USABLE (AVX512_BITALG); - CHECK_CPU_FEATURE_USABLE (AVX512_VPOPCNTDQ); - CHECK_CPU_FEATURE_USABLE (RDPID); - CHECK_CPU_FEATURE_USABLE (KL); - CHECK_CPU_FEATURE_USABLE (CLDEMOTE); - CHECK_CPU_FEATURE_USABLE (MOVDIRI); - CHECK_CPU_FEATURE_USABLE (MOVDIR64B); - CHECK_CPU_FEATURE_USABLE (ENQCMD); - CHECK_CPU_FEATURE_USABLE (SGX_LC); - CHECK_CPU_FEATURE_USABLE (PKS); - CHECK_CPU_FEATURE_USABLE (AVX512_4VNNIW); - CHECK_CPU_FEATURE_USABLE (AVX512_4FMAPS); - CHECK_CPU_FEATURE_USABLE (FSRM); - CHECK_CPU_FEATURE_USABLE (AVX512_VP2INTERSECT); - CHECK_CPU_FEATURE_USABLE (MD_CLEAR); - CHECK_CPU_FEATURE_USABLE (RTM_ALWAYS_ABORT); - CHECK_CPU_FEATURE_USABLE (SERIALIZE); - CHECK_CPU_FEATURE_USABLE (HYBRID); - CHECK_CPU_FEATURE_USABLE (TSXLDTRK); - CHECK_CPU_FEATURE_USABLE (PCONFIG); - CHECK_CPU_FEATURE_USABLE (IBT); - CHECK_CPU_FEATURE_USABLE (AMX_BF16); - CHECK_CPU_FEATURE_USABLE (AVX512_FP16); - CHECK_CPU_FEATURE_USABLE (AMX_TILE); - CHECK_CPU_FEATURE_USABLE (AMX_INT8); - CHECK_CPU_FEATURE_USABLE (IBRS_IBPB); - CHECK_CPU_FEATURE_USABLE (STIBP); - CHECK_CPU_FEATURE_USABLE (L1D_FLUSH); - CHECK_CPU_FEATURE_USABLE (ARCH_CAPABILITIES); - CHECK_CPU_FEATURE_USABLE (CORE_CAPABILITIES); - CHECK_CPU_FEATURE_USABLE (SSBD); - CHECK_CPU_FEATURE_USABLE (LAHF64_SAHF64); - CHECK_CPU_FEATURE_USABLE (SVM); - CHECK_CPU_FEATURE_USABLE (LZCNT); - CHECK_CPU_FEATURE_USABLE (SSE4A); - CHECK_CPU_FEATURE_USABLE (PREFETCHW); - CHECK_CPU_FEATURE_USABLE (XOP); - CHECK_CPU_FEATURE_USABLE (LWP); - CHECK_CPU_FEATURE_USABLE (FMA4); - CHECK_CPU_FEATURE_USABLE (TBM); - CHECK_CPU_FEATURE_USABLE (SYSCALL_SYSRET); - CHECK_CPU_FEATURE_USABLE (NX); - CHECK_CPU_FEATURE_USABLE (PAGE1GB); - CHECK_CPU_FEATURE_USABLE (RDTSCP); - CHECK_CPU_FEATURE_USABLE (LM); - CHECK_CPU_FEATURE_USABLE (XSAVEOPT); - CHECK_CPU_FEATURE_USABLE (XSAVEC); - CHECK_CPU_FEATURE_USABLE (XGETBV_ECX_1); - CHECK_CPU_FEATURE_USABLE (XSAVES); - CHECK_CPU_FEATURE_USABLE (XFD); - CHECK_CPU_FEATURE_USABLE (INVARIANT_TSC); - CHECK_CPU_FEATURE_USABLE (WBNOINVD); - CHECK_CPU_FEATURE_USABLE (AVX_VNNI); - CHECK_CPU_FEATURE_USABLE (AVX512_BF16); - CHECK_CPU_FEATURE_USABLE (FZLRM); - CHECK_CPU_FEATURE_USABLE (FSRS); - CHECK_CPU_FEATURE_USABLE (FSRCS); - CHECK_CPU_FEATURE_USABLE (AESKLE); - CHECK_CPU_FEATURE_USABLE (WIDE_KL); - CHECK_CPU_FEATURE_USABLE (PTWRITE); + printf ("Possible CPU features:\n"); + CHECK_CPU_FEATURE_POSSIBLE (SSE3); + CHECK_CPU_FEATURE_POSSIBLE (PCLMULQDQ); + CHECK_CPU_FEATURE_POSSIBLE (DTES64); + CHECK_CPU_FEATURE_POSSIBLE (MONITOR); + CHECK_CPU_FEATURE_POSSIBLE (DS_CPL); + CHECK_CPU_FEATURE_POSSIBLE (VMX); + CHECK_CPU_FEATURE_POSSIBLE (SMX); + CHECK_CPU_FEATURE_POSSIBLE (EIST); + CHECK_CPU_FEATURE_POSSIBLE (TM2); + CHECK_CPU_FEATURE_POSSIBLE (SSSE3); + CHECK_CPU_FEATURE_POSSIBLE (CNXT_ID); + CHECK_CPU_FEATURE_POSSIBLE (SDBG); + CHECK_CPU_FEATURE_POSSIBLE (FMA); + CHECK_CPU_FEATURE_POSSIBLE (CMPXCHG16B); + CHECK_CPU_FEATURE_POSSIBLE (XTPRUPDCTRL); + CHECK_CPU_FEATURE_POSSIBLE (PDCM); + CHECK_CPU_FEATURE_POSSIBLE (PCID); + CHECK_CPU_FEATURE_POSSIBLE (DCA); + CHECK_CPU_FEATURE_POSSIBLE (SSE4_1); + CHECK_CPU_FEATURE_POSSIBLE (SSE4_2); + CHECK_CPU_FEATURE_POSSIBLE (X2APIC); + CHECK_CPU_FEATURE_POSSIBLE (MOVBE); + CHECK_CPU_FEATURE_POSSIBLE (POPCNT); + CHECK_CPU_FEATURE_POSSIBLE (TSC_DEADLINE); + CHECK_CPU_FEATURE_POSSIBLE (AES); + CHECK_CPU_FEATURE_POSSIBLE (XSAVE); + CHECK_CPU_FEATURE_POSSIBLE (OSXSAVE); + CHECK_CPU_FEATURE_POSSIBLE (AVX); + CHECK_CPU_FEATURE_POSSIBLE (F16C); + CHECK_CPU_FEATURE_POSSIBLE (RDRAND); + CHECK_CPU_FEATURE_POSSIBLE (FPU); + CHECK_CPU_FEATURE_POSSIBLE (VME); + CHECK_CPU_FEATURE_POSSIBLE (DE); + CHECK_CPU_FEATURE_POSSIBLE (PSE); + CHECK_CPU_FEATURE_POSSIBLE (TSC); + CHECK_CPU_FEATURE_POSSIBLE (MSR); + CHECK_CPU_FEATURE_POSSIBLE (PAE); + CHECK_CPU_FEATURE_POSSIBLE (MCE); + CHECK_CPU_FEATURE_POSSIBLE (CX8); + CHECK_CPU_FEATURE_POSSIBLE (APIC); + CHECK_CPU_FEATURE_POSSIBLE (SEP); + CHECK_CPU_FEATURE_POSSIBLE (MTRR); + CHECK_CPU_FEATURE_POSSIBLE (PGE); + CHECK_CPU_FEATURE_POSSIBLE (MCA); + CHECK_CPU_FEATURE_POSSIBLE (CMOV); + CHECK_CPU_FEATURE_POSSIBLE (PAT); + CHECK_CPU_FEATURE_POSSIBLE (PSE_36); + CHECK_CPU_FEATURE_POSSIBLE (PSN); + CHECK_CPU_FEATURE_POSSIBLE (CLFSH); + CHECK_CPU_FEATURE_POSSIBLE (DS); + CHECK_CPU_FEATURE_POSSIBLE (ACPI); + CHECK_CPU_FEATURE_POSSIBLE (MMX); + CHECK_CPU_FEATURE_POSSIBLE (FXSR); + CHECK_CPU_FEATURE_POSSIBLE (SSE); + CHECK_CPU_FEATURE_POSSIBLE (SSE2); + CHECK_CPU_FEATURE_POSSIBLE (SS); + CHECK_CPU_FEATURE_POSSIBLE (HTT); + CHECK_CPU_FEATURE_POSSIBLE (TM); + CHECK_CPU_FEATURE_POSSIBLE (PBE); + CHECK_CPU_FEATURE_POSSIBLE (FSGSBASE); + CHECK_CPU_FEATURE_POSSIBLE (TSC_ADJUST); + CHECK_CPU_FEATURE_POSSIBLE (SGX); + CHECK_CPU_FEATURE_POSSIBLE (BMI1); + CHECK_CPU_FEATURE_POSSIBLE (HLE); + CHECK_CPU_FEATURE_POSSIBLE (AVX2); + CHECK_CPU_FEATURE_POSSIBLE (SMEP); + CHECK_CPU_FEATURE_POSSIBLE (BMI2); + CHECK_CPU_FEATURE_POSSIBLE (ERMS); + CHECK_CPU_FEATURE_POSSIBLE (INVPCID); + CHECK_CPU_FEATURE_POSSIBLE (RTM); + CHECK_CPU_FEATURE_POSSIBLE (RDT_M); + CHECK_CPU_FEATURE_POSSIBLE (DEPR_FPU_CS_DS); + CHECK_CPU_FEATURE_POSSIBLE (MPX); + CHECK_CPU_FEATURE_POSSIBLE (RDT_A); + CHECK_CPU_FEATURE_POSSIBLE (AVX512F); + CHECK_CPU_FEATURE_POSSIBLE (AVX512DQ); + CHECK_CPU_FEATURE_POSSIBLE (RDSEED); + CHECK_CPU_FEATURE_POSSIBLE (ADX); + CHECK_CPU_FEATURE_POSSIBLE (SMAP); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_IFMA); + CHECK_CPU_FEATURE_POSSIBLE (CLFLUSHOPT); + CHECK_CPU_FEATURE_POSSIBLE (CLWB); + CHECK_CPU_FEATURE_POSSIBLE (TRACE); + CHECK_CPU_FEATURE_POSSIBLE (AVX512PF); + CHECK_CPU_FEATURE_POSSIBLE (AVX512ER); + CHECK_CPU_FEATURE_POSSIBLE (AVX512CD); + CHECK_CPU_FEATURE_POSSIBLE (SHA); + CHECK_CPU_FEATURE_POSSIBLE (AVX512BW); + CHECK_CPU_FEATURE_POSSIBLE (AVX512VL); + CHECK_CPU_FEATURE_POSSIBLE (PREFETCHWT1); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_VBMI); + CHECK_CPU_FEATURE_POSSIBLE (UMIP); + CHECK_CPU_FEATURE_POSSIBLE (PKU); + CHECK_CPU_FEATURE_POSSIBLE (OSPKE); + CHECK_CPU_FEATURE_POSSIBLE (WAITPKG); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_VBMI2); + CHECK_CPU_FEATURE_POSSIBLE (SHSTK); + CHECK_CPU_FEATURE_POSSIBLE (GFNI); + CHECK_CPU_FEATURE_POSSIBLE (VAES); + CHECK_CPU_FEATURE_POSSIBLE (VPCLMULQDQ); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_VNNI); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_BITALG); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_VPOPCNTDQ); + CHECK_CPU_FEATURE_POSSIBLE (RDPID); + CHECK_CPU_FEATURE_POSSIBLE (KL); + CHECK_CPU_FEATURE_POSSIBLE (CLDEMOTE); + CHECK_CPU_FEATURE_POSSIBLE (MOVDIRI); + CHECK_CPU_FEATURE_POSSIBLE (MOVDIR64B); + CHECK_CPU_FEATURE_POSSIBLE (ENQCMD); + CHECK_CPU_FEATURE_POSSIBLE (SGX_LC); + CHECK_CPU_FEATURE_POSSIBLE (PKS); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_4VNNIW); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_4FMAPS); + CHECK_CPU_FEATURE_POSSIBLE (FSRM); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_VP2INTERSECT); + CHECK_CPU_FEATURE_POSSIBLE (MD_CLEAR); + CHECK_CPU_FEATURE_POSSIBLE (RTM_ALWAYS_ABORT); + CHECK_CPU_FEATURE_POSSIBLE (SERIALIZE); + CHECK_CPU_FEATURE_POSSIBLE (HYBRID); + CHECK_CPU_FEATURE_POSSIBLE (TSXLDTRK); + CHECK_CPU_FEATURE_POSSIBLE (PCONFIG); + CHECK_CPU_FEATURE_POSSIBLE (IBT); + CHECK_CPU_FEATURE_POSSIBLE (AMX_BF16); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_FP16); + CHECK_CPU_FEATURE_POSSIBLE (AMX_TILE); + CHECK_CPU_FEATURE_POSSIBLE (AMX_INT8); + CHECK_CPU_FEATURE_POSSIBLE (IBRS_IBPB); + CHECK_CPU_FEATURE_POSSIBLE (STIBP); + CHECK_CPU_FEATURE_POSSIBLE (L1D_FLUSH); + CHECK_CPU_FEATURE_POSSIBLE (ARCH_CAPABILITIES); + CHECK_CPU_FEATURE_POSSIBLE (CORE_CAPABILITIES); + CHECK_CPU_FEATURE_POSSIBLE (SSBD); + CHECK_CPU_FEATURE_POSSIBLE (LAHF64_SAHF64); + CHECK_CPU_FEATURE_POSSIBLE (SVM); + CHECK_CPU_FEATURE_POSSIBLE (LZCNT); + CHECK_CPU_FEATURE_POSSIBLE (SSE4A); + CHECK_CPU_FEATURE_POSSIBLE (PREFETCHW); + CHECK_CPU_FEATURE_POSSIBLE (XOP); + CHECK_CPU_FEATURE_POSSIBLE (LWP); + CHECK_CPU_FEATURE_POSSIBLE (FMA4); + CHECK_CPU_FEATURE_POSSIBLE (TBM); + CHECK_CPU_FEATURE_POSSIBLE (SYSCALL_SYSRET); + CHECK_CPU_FEATURE_POSSIBLE (NX); + CHECK_CPU_FEATURE_POSSIBLE (PAGE1GB); + CHECK_CPU_FEATURE_POSSIBLE (RDTSCP); + CHECK_CPU_FEATURE_POSSIBLE (LM); + CHECK_CPU_FEATURE_POSSIBLE (XSAVEOPT); + CHECK_CPU_FEATURE_POSSIBLE (XSAVEC); + CHECK_CPU_FEATURE_POSSIBLE (XGETBV_ECX_1); + CHECK_CPU_FEATURE_POSSIBLE (XSAVES); + CHECK_CPU_FEATURE_POSSIBLE (XFD); + CHECK_CPU_FEATURE_POSSIBLE (INVARIANT_TSC); + CHECK_CPU_FEATURE_POSSIBLE (WBNOINVD); + CHECK_CPU_FEATURE_POSSIBLE (AVX_VNNI); + CHECK_CPU_FEATURE_POSSIBLE (AVX512_BF16); + CHECK_CPU_FEATURE_POSSIBLE (FZLRM); + CHECK_CPU_FEATURE_POSSIBLE (FSRS); + CHECK_CPU_FEATURE_POSSIBLE (FSRCS); + CHECK_CPU_FEATURE_POSSIBLE (AESKLE); + CHECK_CPU_FEATURE_POSSIBLE (WIDE_KL); + CHECK_CPU_FEATURE_POSSIBLE (PTWRITE); return 0; } diff --git a/sysdeps/x86/tst-ifunc-isa.h b/sysdeps/x86/tst-ifunc-isa.h index 6d906966a7..af901fbb31 100644 --- a/sysdeps/x86/tst-ifunc-isa.h +++ b/sysdeps/x86/tst-ifunc-isa.h @@ -1,4 +1,4 @@ -/* IFUNC resolver with CPU_FEATURE_USABLE. +/* IFUNC resolver with CPU_FEATURE_POSSIBLE. Copyright (C) 2021 Free Software Foundation, Inc. This file is part of the GNU C Library. @@ -32,15 +32,15 @@ enum isa __attribute__ ((__optimize__ ("-fno-stack-protector"))) get_isa (void) { - if (CPU_FEATURE_USABLE (AVX512F)) + if (CPU_FEATURE_POSSIBLE (AVX512F)) return avx512f; - if (CPU_FEATURE_USABLE (AVX2)) + if (CPU_FEATURE_POSSIBLE (AVX2)) return avx2; - if (CPU_FEATURE_USABLE (AVX)) + if (CPU_FEATURE_POSSIBLE (AVX)) return avx; - if (CPU_FEATURE_USABLE (SSE4_2)) + if (CPU_FEATURE_POSSIBLE (SSE4_2)) return sse4_2; - if (CPU_FEATURE_USABLE (SSE2)) + if (CPU_FEATURE_POSSIBLE (SSE2)) return sse2; return none; } diff --git a/sysdeps/x86/tst-string-rtm.h b/sysdeps/x86/tst-string-rtm.h index d2470afa1e..5ac65b5a0f 100644 --- a/sysdeps/x86/tst-string-rtm.h +++ b/sysdeps/x86/tst-string-rtm.h @@ -26,7 +26,7 @@ static int do_test_1 (const char *name, unsigned int loop, int (*prepare) (void), int (*function) (void)) { - if (!CPU_FEATURE_USABLE (RTM)) + if (!CPU_FEATURE_POSSIBLE (RTM)) return EXIT_UNSUPPORTED; int status = prepare (); diff --git a/sysdeps/x86_64/fpu/math-tests-arch.h b/sysdeps/x86_64/fpu/math-tests-arch.h index f521e218b9..ce074a46b4 100644 --- a/sysdeps/x86_64/fpu/math-tests-arch.h +++ b/sysdeps/x86_64/fpu/math-tests-arch.h @@ -24,7 +24,7 @@ # define CHECK_ARCH_EXT \ do \ { \ - if (!CPU_FEATURE_USABLE (AVX)) return; \ + if (!CPU_FEATURE_POSSIBLE (AVX)) return; \ } \ while (0) @@ -34,7 +34,7 @@ # define CHECK_ARCH_EXT \ do \ { \ - if (!CPU_FEATURE_USABLE (AVX2)) return; \ + if (!CPU_FEATURE_POSSIBLE (AVX2)) return; \ } \ while (0) @@ -44,7 +44,7 @@ # define CHECK_ARCH_EXT \ do \ { \ - if (!CPU_FEATURE_USABLE (AVX512F)) return; \ + if (!CPU_FEATURE_POSSIBLE (AVX512F)) return; \ } \ while (0)