cpuid: Minor improvements
authorAhmed Samy <f.fallen45@gmail.com>
Wed, 25 Sep 2013 14:46:09 +0000 (14:46 +0000)
committerAhmed Samy <f.fallen45@gmail.com>
Wed, 25 Sep 2013 14:46:09 +0000 (14:46 +0000)
Remove the assembly file that checks if the CPUID instruction is
supported and have it in inline assembly as suggested by Rusty.

Signed-off-by: Ahmed Samy <f.fallen45@gmail.com>
Makefile-ccan
ccan/cpuid/cpuid.c
ccan/cpuid/cpuid.h
ccan/cpuid/issupprted.S [deleted file]
ccan/cpuid/test/run.c

index fd959ffcd1c8db1671911314155bc040033fde0f..86d6ac0c44e3ca149d1e0fefb2448379bf5df4d3 100644 (file)
@@ -113,7 +113,6 @@ DIRS=$(patsubst %/, %, $(sort $(foreach m, $(filter-out $(MODS_EXCLUDE), $(MODS_
 ccan/%-Makefile:
        @echo $@: $(wildcard ccan/$*/*.[ch]) ccan/$*/_info > $@
        @echo ccan/$*.o: $(patsubst %.c, %.o, $(wildcard ccan/$*/*.c)) >> $@
-       @echo ccan/$*.o: $(patsubst %.S, %.o, $(wildcard ccan/$*/*.S)) >> $@
 
 # We compile all the ccan/foo/*.o files together into ccan/foo.o
 OBJFILES=$(DIRS:=.o)
index 6a45116d710f08410d9bad56d0afdafd1c912fd2..d6d27799e9383ae0b777a225691358c67857cd69 100644 (file)
 /* Only compile this file if we're on a x86 machine.  */
 #if defined(__i386__) || defined(__i386) || defined(__x86_64) \
        || defined(_M_AMD64) || defined(__M_X64)
-#include <stdint.h>
-#include <string.h>
-
 #include "cpuid.h"
 
+#include <string.h>
+
 enum {
        CPU_PROC_BRAND_STRING_INTERNAL0                 = 0x80000003,
        CPU_PROC_BRAND_STRING_INTERNAL1                 = 0x80000004
@@ -65,61 +64,87 @@ static void ___cpuid(cpuid_t info, uint32_t *eax, uint32_t *ebx, uint32_t *ecx,
 static struct {
        int feature;
        unsigned mask;
-       int instruction;        /* 0 = ecx, 1 = edx.  */
+       bool use_edx;           /* ecx will be used if false.  */
 } features[] = {
-       { CF_MMX,               1 << 23,        1 },
-       { CF_SSE,               1 << 25,        1 },
-       { CF_SSE2,              1 << 26,        1 },
-       { CF_SSE3,              1 << 9,         0 },
-       { CF_FPU,               1 << 0,         1 },
+       { CF_MMX,               1 << 23,        true },
+       { CF_SSE,               1 << 25,        true },
+       { CF_SSE2,              1 << 26,        true },
+       { CF_SSE3,              1 << 9,         false },
+       { CF_FPU,               1 << 0,         true },
 
-       { CF_TSC,               1 << 4,         1 },
-       { CF_MSR,               1 << 5,         1 },
+       { CF_TSC,               1 << 4,         true },
+       { CF_MSR,               1 << 5,         true },
 
-       { CF_SSSE3,             1 << 9,         0 },
-       { CF_AVX,               1 << 28,        0 },
+       { CF_SSSE3,             1 << 9,         false },
+       { CF_AVX,               1 << 28,        false },
 
        /* Extended ones.  */
-       { CEF_x64,              1 << 30,        1 },
-       { CEF_FPU,              1 << 0,         1 },
-       { CEF_DE,               1 << 2,         1 },
-       { CEF_SYSCALLRET,       1 << 11,        1 },
-       { CEF_CMOV,             1 << 15,        1 },
-
-       { CEF_SSE4a,            1 << 6,         0 },
-       { CEF_FMA4,             1 << 16,        0 },
-       { CEF_XOP,              1 << 11,        0 }
+       { CEF_x64,              1 << 30,        true },
+       { CEF_FPU,              1 << 0,         true },
+       { CEF_DE,               1 << 2,         true },
+       { CEF_SYSCALLRET,       1 << 11,        true },
+       { CEF_CMOV,             1 << 15,        true },
+
+       { CEF_SSE4a,            1 << 6,         false },
+       { CEF_FMA4,             1 << 16,        false },
+       { CEF_XOP,              1 << 11,        false }
 };
 
-static int has_feature(int feature, uint32_t ecx, uint32_t edx)
+static bool has_feature(int feature, uint32_t ecx, uint32_t edx)
 {
        int i;
 
        for (i = 0; i < sizeof(features) / sizeof(features[0]); ++i) {
                if (features[i].feature == feature) {
-                       if (features[i].instruction == 0)
-                               return (ecx & features[i].mask);
-                       else
+                       if (features[i].use_edx)
                                return (edx & features[i].mask);
+                       else
+                               return (ecx & features[i].mask);
                }
        }
 
-       return 0;
+       return false;
 }
 
-int cpuid_test_feature(cpuid_t feature)
+bool cpuid_is_supported(void)
+{
+       int ret = 0;
+
+       asm volatile(
+               "pushfl\n\t"
+               "popl %%eax\n\t"
+               "movl %%eax, %%ecx\n\t"
+               "xorl $0x200000, %%eax\n\t"
+               "pushl %%eax\n\t"
+               "popfl\n\t"
+
+               "pushfl\n\t"
+               "popl %%eax\n\t"
+               "xorl %%ecx, %%eax\n\t"
+               "shrl $21, %%eax\n\t"
+               "andl $1, %%eax\n\t"
+               "pushl %%ecx\n\t"
+               "popfl\n\t"
+
+               : "=a" (ret)
+       );
+
+       return !!ret;
+}
+
+bool cpuid_test_feature(cpuid_t feature)
 {
        if (feature > CPU_VIRT_PHYS_ADDR_SIZES || feature < CPU_EXTENDED_PROC_INFO_FEATURE_BITS)
-               return 0;
+               return false;
 
        return (feature <= cpuid_highest_ext_func_supported());
 }
 
-int cpuid_has_feature(int feature, int extended)
+bool cpuid_has_feature(int feature, bool extended)
 {
        uint32_t eax, ebx, ecx, edx;
 
-       if (extended == 0)
+       if (!extended)
                ___cpuid(CPU_PROCINFO_AND_FEATUREBITS, &eax, &ebx, &ecx, &edx);
        else
                ___cpuid(CPU_EXTENDED_PROC_INFO_FEATURE_BITS, &eax, &ebx, &ecx, &edx);
@@ -175,9 +200,9 @@ const char *cpuid_get_cpu_type_string(const cputype_t cputype)
        return cpuids[(int)cputype];
 }
 
-int cpuid_highest_ext_func_supported(void)
+uint32_t cpuid_highest_ext_func_supported(void)
 {
-       static int highest;
+       static uint32_t highest;
 
        if (!highest) {
                asm volatile(
@@ -190,7 +215,7 @@ int cpuid_highest_ext_func_supported(void)
        return highest;
 }
 
-void cpuid(cpuid_t info, void *buf)
+void cpuid(cpuid_t info, uint32_t *buf)
 {
        /* Sanity checks, make sure we're not trying to do something
         * invalid or we are trying to get information that isn't supported
@@ -199,14 +224,13 @@ void cpuid(cpuid_t info, void *buf)
                && !cpuid_test_feature(info)))
                return;
 
-       uint32_t *ubuf = buf;
        if (info == CPU_PROC_BRAND_STRING) {
-               ___cpuid(CPU_PROC_BRAND_STRING,           &ubuf[0], &ubuf[1], &ubuf[2],  &ubuf[3]);
-               ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL0, &ubuf[4], &ubuf[5], &ubuf[6],  &ubuf[7]);
-               ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL1, &ubuf[8], &ubuf[9], &ubuf[10], &ubuf[11]);
+               ___cpuid(CPU_PROC_BRAND_STRING,           &buf[0], &buf[1], &buf[2],  &buf[3]);
+               ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL0, &buf[4], &buf[5], &buf[6],  &buf[7]);
+               ___cpuid(CPU_PROC_BRAND_STRING_INTERNAL1, &buf[8], &buf[9], &buf[10], &buf[11]);
                return;
        } else if (info == CPU_HIGHEST_EXTENDED_FUNCTION_SUPPORTED) {
-               *ubuf = cpuid_highest_ext_func_supported();
+               *buf = cpuid_highest_ext_func_supported();
                return;
        }
 
@@ -215,44 +239,42 @@ void cpuid(cpuid_t info, void *buf)
 
        switch (info) {
                case CPU_VENDORID:
-                       ubuf[0] = ebx;
-                       ubuf[1] = edx;
-                       ubuf[2] = ecx;
+                       buf[0] = ebx;
+                       buf[1] = edx;
+                       buf[2] = ecx;
                        break;
                case CPU_PROCINFO_AND_FEATUREBITS:
-                       ubuf[0] = eax;  /* The so called "signature" of the CPU.  */
-                       ubuf[1] = edx;  /* Feature flags #1.  */
-                       ubuf[2] = ecx;  /* Feature flags #2.  */
-                       ubuf[3] = ebx;  /* Additional feature information.  */
+                       buf[0] = eax;   /* The so called "signature" of the CPU.  */
+                       buf[1] = edx;   /* Feature flags #1.  */
+                       buf[2] = ecx;   /* Feature flags #2.  */
+                       buf[3] = ebx;   /* Additional feature information.  */
                        break;
                case CPU_CACHE_AND_TLBD_INFO:
-                       ubuf[0] = eax;
-                       ubuf[1] = ebx;
-                       ubuf[2] = ecx;
-                       ubuf[3] = edx;
+                       buf[0] = eax;
+                       buf[1] = ebx;
+                       buf[2] = ecx;
+                       buf[3] = edx;
                        break;
                case CPU_EXTENDED_PROC_INFO_FEATURE_BITS:
-                       ubuf[0] = edx;
-                       ubuf[1] = ecx;
+                       buf[0] = edx;
+                       buf[1] = ecx;
                        break;
                case CPU_L1_CACHE_AND_TLB_IDS:
                        break;
                case CPU_EXTENDED_L2_CACHE_FEATURES:
-                       *ubuf = ecx;
+                       *buf = ecx;
                        break;
                case CPU_ADV_POWER_MGT_INFO:
-                       *ubuf = edx;
+                       *buf = edx;
                        break;
                case CPU_VIRT_PHYS_ADDR_SIZES:
-                       *ubuf = eax;
+                       *buf = eax;
                        break;
                default:
-                       *ubuf = 0xbaadf00d;
+                       *buf = 0xbaadf00d;
                        break;
        }
 }
 
-#else
-#warning "Cannot compile this file on a non-x86 machine"
 #endif
 
index 2861394608313dede06e863900189af6dd8dafef..b0d9df19278c741da039037b9017b9ccde6ac577 100644 (file)
@@ -22,6 +22,9 @@
 #ifndef CCAN_CPUID_H
 #define CCAN_CPUID_H
 
+#include <stdbool.h>
+#include <stdint.h>
+
 /**
  * enum cpuid - stuff to get information on from the CPU.
  *
@@ -111,6 +114,9 @@ typedef enum cputype {
        CT_KVM
 } cputype_t;
 
+#if defined(__i386__) || defined(__i386) || defined(__x86_64) \
+       || defined(_M_AMD64) || defined(__M_X64)
+
 /**
  * cpuid_get_cpu_type - Get CPU Type
  *
@@ -132,11 +138,11 @@ const char *cpuid_get_cpu_type_string(const cputype_t cputype);
  *
  * CPUID is not supported by old CPUS.
  *
- * Returns 1 if the cpuid instruction is supported, 0 otherwise.
+ * Returns true if the cpuid instruction is supported, false otherwise.
  *
  * See also: cpuid()
  */
-int cpuid_is_supported(void);
+bool cpuid_is_supported(void);
 
 /**
  * cpuid_highest_ext_func_supported - Get the highest extended function supported
@@ -152,7 +158,7 @@ int cpuid_is_supported(void);
  *
  * See also: cpuid()
  */
-int cpuid_highest_ext_func_supported(void);
+uint32_t cpuid_highest_ext_func_supported(void);
 
 /**
  * cpuid - Get Some information from the CPU.
@@ -190,43 +196,56 @@ int cpuid_highest_ext_func_supported(void);
  *
  * If an invalid flag has been passed a 0xbaadf00d is returned in *buf.
  */
-void cpuid(cpuid_t info, void *buf);
+void cpuid(cpuid_t info, uint32_t *buf);
 
 /**
  * cpuid_test_feature - Test if @feature is available
  *
- * Returns 1 if feature is supported, 0 otherwise.
+ * Returns true if feature is supported, false otherwise.
  *
  * The feature parameter must be >= CPU_EXTENDED_PROC_INFO_FEATURE_BITS
  *  and <= CPU_VIRT_PHYS_ADDR_SIZES.
  */
-int cpuid_test_feature(cpuid_t feature);
+bool cpuid_test_feature(cpuid_t feature);
 
 /**
  * cpuid_has_feature - Test if @feature is supported
  *
  * Test if the CPU supports MMX/SSE* etc.
  * For the extended parameter, usually you want to pass it as
- * 0 if you're not passing CEF_*.
+ * false if you're not passing CEF_*.
  *
  * For more information about the CPU extended features, have a look
  * at:
  *     http://en.wikipedia.org/wiki/CPUID
  *
- * Returns 1 if the feature is available, 0 otherwise.
+ * Returns true if the feature is available, false otherwise.
  */
-#define cpuid_has_mmx()        cpuid_has_feature(CF_MMX,       0)
-#define cpuid_has_sse()        cpuid_has_feature(CF_SSE,       0)
-#define cpuid_has_sse2()       cpuid_has_feature(CF_SSE2,      0)
-#define cpuid_has_sse3()       cpuid_has_feature(CF_SSE3,      0)
-#define cpuid_has_ssse3()      cpuid_has_feature(CF_SSSE3,     0)
-#define cpuid_has_avx()        cpuid_has_feature(CF_AVX,       0)
-#define cpuid_has_fma()        cpuid_has_feature(CF_FMA,       0)
-#define cpuid_has_x64()        cpuid_has_feature(CEF_x64,      1)
-#define cpuid_has_sse4a()      cpuid_has_feature(CEF_SSE4a,    1)
-#define cpuid_has_fma4()       cpuid_has_feature(CEF_FMA4,     1)
-#define cpuid_has_xop()        cpuid_has_feature(CEF_XOP,      1)
-int cpuid_has_feature(int feature, int extended);
+#define cpuid_has_mmx()        cpuid_has_feature(CF_MMX,       false)
+#define cpuid_has_sse()        cpuid_has_feature(CF_SSE,       false)
+#define cpuid_has_sse2()       cpuid_has_feature(CF_SSE2,      false)
+#define cpuid_has_sse3()       cpuid_has_feature(CF_SSE3,      false)
+#define cpuid_has_ssse3()      cpuid_has_feature(CF_SSSE3,     false)
+#define cpuid_has_avx()        cpuid_has_feature(CF_AVX,       false)
+#define cpuid_has_fma()        cpuid_has_feature(CF_FMA,       false)
+#define cpuid_has_x64()        cpuid_has_feature(CEF_x64,      true)
+#define cpuid_has_sse4a()      cpuid_has_feature(CEF_SSE4a,    true)
+#define cpuid_has_fma4()       cpuid_has_feature(CEF_FMA4,     true)
+#define cpuid_has_xop()        cpuid_has_feature(CEF_XOP,      true)
+bool cpuid_has_feature(int feature, bool extended);
+
+#else
+
+#define cpuid_get_cpu_type()                   BUILD_ASSERT_OR_ZERO(0)
+#define cpuid_get_cpu_type_string()            BUILD_ASSERT_OR_ZERO(0)
 
+#define cpuid_is_supported()                   BUILD_ASSERT_OR_ZERO(0)
+#define cpuid(info, buf)                       BUILD_ASSERT_OR_ZERO(0)
+
+#define cpuid_highest_ext_func_supported()     BUILD_ASSERT_OR_ZERO(0)
+#define cpuid_test_feature(feature)            BUILD_ASSERT_OR_ZERO(0)
+#define cpuid_has_feature(feature, ext)        BUILD_ASSERT_OR_ZERO(0)
+
+#endif
 #endif
 
diff --git a/ccan/cpuid/issupprted.S b/ccan/cpuid/issupprted.S
deleted file mode 100644 (file)
index 80ed0fd..0000000
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-  Test if the CPUID instruction is available.
-  returns 1 if so, 0 otherwise.  */
-
-/* Only compile this file if we're on a x86 machine.  */
-#if defined(__i386__) || defined(__i386) || defined(__x86_64) \
-       || defined(_M_AMD64) || defined(__M_X64)
-
-.section .text
-.global cpuid_is_supported
-.type cpuid_is_supported, @function
-cpuid_is_supported:
-       nop
-
-       pushfl
-       popl %eax
-       movl %eax, %ecx
-       xorl $0x200000, %eax
-       pushl %eax
-       popfl
-
-       pushfl
-       popl %eax
-       xorl %ecx, %eax
-       shrl $21, %eax
-       andl $1, %eax
-       pushl %ecx
-       popfl
-
-       ret
-
-       .size cpuid_is_supported, .-cpuid_is_supported
-#endif
-
index 21e9aa60d38d2eae7be25f999f9de322a91e53a9..c96f3ab8dba0ed5b9ad5fc71e16aa94bbef11356 100644 (file)
@@ -13,7 +13,7 @@ int main()
        printf ("Vendor ID: %s\n", cpuid_get_cpu_type_string (cpuid_get_cpu_type ()));
 
        char buf[48];
-       cpuid(CPU_PROC_BRAND_STRING, buf);
+       cpuid(CPU_PROC_BRAND_STRING, (uint32_t *)buf);
        printf ("Processor Brand: %s\n", buf);
 
        printf ("Highest extended function supported: %#010x\n", cpuid_highest_ext_func_supported());
@@ -29,7 +29,7 @@ int main()
        cpuid(CPU_VIRT_PHYS_ADDR_SIZES, &s.w);
        printf ("Physical address size: %d\nVirtual: %d\n", s.phys_bits, s.virt_bits);
 
-       int extfeatures[2];
+       uint32_t extfeatures[2];
        cpuid(CPU_EXTENDED_PROC_INFO_FEATURE_BITS, extfeatures);
        printf ("Extended processor info and feature bits: %d %d\n", extfeatures[0], extfeatures[1]);
 
@@ -45,11 +45,12 @@ int main()
        } l2c;
 
        cpuid(CPU_EXTENDED_L2_CACHE_FEATURES, &l2c.w);
-       printf ("L2 Cache Size: %ld KB\tLine Size: %ld bytes\tAssociativity: %02xh\n",
+       printf ("L2 Cache Size: %u KB\tLine Size: %u bytes\tAssociativity: %02xh\n",
                        l2c.cache_size, l2c.line_size, l2c.assoc);
 
-       int invalid;
+       uint32_t invalid;
        cpuid(0x0ffffffUL, &invalid);
        printf ("Testing invalid: %#010x\n", invalid);
        return 0;
 }
+