johann/cpu_features
1
0
Fork 0
mirror of https://github.com/google/cpu_features.git synced 2025-04-28 07:23:37 +02:00
Code Issues Releases Wiki Activity

Use enum properly to directly access kConfig struct (#83)

Browse Source
This commit is contained in:
Guillaume Chatelet 2019-07-05 08:47:41 +02:00 committed by GitHub
commit 24d7f78814
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 99 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/cpuinfo_aarch64.c
View File

@ -20,6 +20,7 @@
#include "internal/string_view.h" #include "internal/string_view.h"
#include "internal/unix_features_aggregator.h" #include "internal/unix_features_aggregator.h"
#include <assert.h>
#include <ctype.h> #include <ctype.h>
DECLARE_SETTER(Aarch64Features, fp) DECLARE_SETTER(Aarch64Features, fp)
@ -31,13 +32,13 @@ DECLARE_SETTER(Aarch64Features, sha2)
DECLARE_SETTER(Aarch64Features, crc32) DECLARE_SETTER(Aarch64Features, crc32)
static const CapabilityConfig kConfigs[] = { static const CapabilityConfig kConfigs[] = {
{{AARCH64_HWCAP_FP, 0}, "fp", &set_fp}, // [AARCH64_FP] = {{AARCH64_HWCAP_FP, 0}, "fp", &set_fp}, //
{{AARCH64_HWCAP_ASIMD, 0}, "asimd", &set_asimd}, // [AARCH64_ASIMD] = {{AARCH64_HWCAP_ASIMD, 0}, "asimd", &set_asimd}, //
{{AARCH64_HWCAP_AES, 0}, "aes", &set_aes}, // [AARCH64_AES] = {{AARCH64_HWCAP_AES, 0}, "aes", &set_aes}, //
{{AARCH64_HWCAP_PMULL, 0}, "pmull", &set_pmull}, // [AARCH64_PMULL] = {{AARCH64_HWCAP_PMULL, 0}, "pmull", &set_pmull}, //
{{AARCH64_HWCAP_SHA1, 0}, "sha1", &set_sha1}, // [AARCH64_SHA1] = {{AARCH64_HWCAP_SHA1, 0}, "sha1", &set_sha1}, //
{{AARCH64_HWCAP_SHA2, 0}, "sha2", &set_sha2}, // [AARCH64_SHA2] = {{AARCH64_HWCAP_SHA2, 0}, "sha2", &set_sha2}, //
{{AARCH64_HWCAP_CRC32, 0}, "crc32", &set_crc32}, // [AARCH64_CRC32] {{AARCH64_HWCAP_CRC32, 0}, "crc32", &set_crc32}, //
}; };
static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig); static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
@ -79,6 +80,8 @@ static void FillProcCpuInfoData(Aarch64Info* const info) {
static const Aarch64Info kEmptyAarch64Info; static const Aarch64Info kEmptyAarch64Info;
Aarch64Info GetAarch64Info(void) { Aarch64Info GetAarch64Info(void) {
assert(kConfigsSize == AARCH64_LAST_);
// capabilities are fetched from both getauxval and /proc/cpuinfo so we can // capabilities are fetched from both getauxval and /proc/cpuinfo so we can
// have some information if the executable is sandboxed (aka no access to // have some information if the executable is sandboxed (aka no access to
// /proc/cpuinfo). // /proc/cpuinfo).
@ -119,23 +122,7 @@ int GetAarch64FeaturesEnumValue(const Aarch64Features* features,
} }
const char* GetAarch64FeaturesEnumName(Aarch64FeaturesEnum value) { const char* GetAarch64FeaturesEnumName(Aarch64FeaturesEnum value) {
switch (value) { if(value >= kConfigsSize)
case AARCH64_FP: return "unknown feature";
return "fp"; return kConfigs[value].proc_cpuinfo_flag;
case AARCH64_ASIMD:
return "asimd";
case AARCH64_AES:
return "aes";
case AARCH64_PMULL:
return "pmull";
case AARCH64_SHA1:
return "sha1";
case AARCH64_SHA2:
return "sha2";
case AARCH64_CRC32:
return "crc32";
case AARCH64_LAST_:
break;
}
return "unknown feature";
} }

115
src/cpuinfo_arm.c
View File

@ -21,6 +21,7 @@
#include "internal/string_view.h" #include "internal/string_view.h"
#include "internal/unix_features_aggregator.h" #include "internal/unix_features_aggregator.h"
#include <assert.h>
#include <ctype.h> #include <ctype.h>
DECLARE_SETTER(ArmFeatures, swp) DECLARE_SETTER(ArmFeatures, swp)
@ -52,33 +53,33 @@ DECLARE_SETTER(ArmFeatures, sha2)
DECLARE_SETTER(ArmFeatures, crc32) DECLARE_SETTER(ArmFeatures, crc32)
static const CapabilityConfig kConfigs[] = { static const CapabilityConfig kConfigs[] = {
{{ARM_HWCAP_SWP, 0}, "swp", &set_swp}, // [ARM_SWP] = {{ARM_HWCAP_SWP, 0}, "swp", &set_swp}, //
{{ARM_HWCAP_HALF, 0}, "half", &set_half}, // [ARM_HALF] = {{ARM_HWCAP_HALF, 0}, "half", &set_half}, //
{{ARM_HWCAP_THUMB, 0}, "thumb", &set_thumb}, // [ARM_THUMB] = {{ARM_HWCAP_THUMB, 0}, "thumb", &set_thumb}, //
{{ARM_HWCAP_26BIT, 0}, "26bit", &set__26bit}, // [ARM_26BIT] = {{ARM_HWCAP_26BIT, 0}, "26bit", &set__26bit}, //
{{ARM_HWCAP_FAST_MULT, 0}, "fastmult", &set_fastmult}, // [ARM_FASTMULT] = {{ARM_HWCAP_FAST_MULT, 0}, "fastmult", &set_fastmult}, //
{{ARM_HWCAP_FPA, 0}, "fpa", &set_fpa}, // [ARM_FPA] = {{ARM_HWCAP_FPA, 0}, "fpa", &set_fpa}, //
{{ARM_HWCAP_VFP, 0}, "vfp", &set_vfp}, // [ARM_VFP] = {{ARM_HWCAP_VFP, 0}, "vfp", &set_vfp}, //
{{ARM_HWCAP_EDSP, 0}, "edsp", &set_edsp}, // [ARM_EDSP] = {{ARM_HWCAP_EDSP, 0}, "edsp", &set_edsp}, //
{{ARM_HWCAP_JAVA, 0}, "java", &set_java}, // [ARM_JAVA] = {{ARM_HWCAP_JAVA, 0}, "java", &set_java}, //
{{ARM_HWCAP_IWMMXT, 0}, "iwmmxt", &set_iwmmxt}, // [ARM_IWMMXT] = {{ARM_HWCAP_IWMMXT, 0}, "iwmmxt", &set_iwmmxt}, //
{{ARM_HWCAP_CRUNCH, 0}, "crunch", &set_crunch}, // [ARM_CRUNCH] = {{ARM_HWCAP_CRUNCH, 0}, "crunch", &set_crunch}, //
{{ARM_HWCAP_THUMBEE, 0}, "thumbee", &set_thumbee}, // [ARM_THUMBEE] = {{ARM_HWCAP_THUMBEE, 0}, "thumbee", &set_thumbee}, //
{{ARM_HWCAP_NEON, 0}, "neon", &set_neon}, // [ARM_NEON] = {{ARM_HWCAP_NEON, 0}, "neon", &set_neon}, //
{{ARM_HWCAP_VFPV3, 0}, "vfpv3", &set_vfpv3}, // [ARM_VFPV3] = {{ARM_HWCAP_VFPV3, 0}, "vfpv3", &set_vfpv3}, //
{{ARM_HWCAP_VFPV3D16, 0}, "vfpv3d16", &set_vfpv3d16}, // [ARM_VFPV3D16] = {{ARM_HWCAP_VFPV3D16, 0}, "vfpv3d16", &set_vfpv3d16}, //
{{ARM_HWCAP_TLS, 0}, "tls", &set_tls}, // [ARM_TLS] = {{ARM_HWCAP_TLS, 0}, "tls", &set_tls}, //
{{ARM_HWCAP_VFPV4, 0}, "vfpv4", &set_vfpv4}, // [ARM_VFPV4] = {{ARM_HWCAP_VFPV4, 0}, "vfpv4", &set_vfpv4}, //
{{ARM_HWCAP_IDIVA, 0}, "idiva", &set_idiva}, // [ARM_IDIVA] = {{ARM_HWCAP_IDIVA, 0}, "idiva", &set_idiva}, //
{{ARM_HWCAP_IDIVT, 0}, "idivt", &set_idivt}, // [ARM_IDIVT] = {{ARM_HWCAP_IDIVT, 0}, "idivt", &set_idivt}, //
{{ARM_HWCAP_VFPD32, 0}, "vfpd32", &set_vfpd32}, // [ARM_VFPD32] = {{ARM_HWCAP_VFPD32, 0}, "vfpd32", &set_vfpd32}, //
{{ARM_HWCAP_LPAE, 0}, "lpae", &set_lpae}, // [ARM_LPAE] = {{ARM_HWCAP_LPAE, 0}, "lpae", &set_lpae}, //
{{ARM_HWCAP_EVTSTRM, 0}, "evtstrm", &set_evtstrm}, // [ARM_EVTSTRM] = {{ARM_HWCAP_EVTSTRM, 0}, "evtstrm", &set_evtstrm}, //
{{0, ARM_HWCAP2_AES}, "aes", &set_aes}, // [ARM_AES] = {{0, ARM_HWCAP2_AES}, "aes", &set_aes}, //
{{0, ARM_HWCAP2_PMULL}, "pmull", &set_pmull}, // [ARM_PMULL] = {{0, ARM_HWCAP2_PMULL}, "pmull", &set_pmull}, //
{{0, ARM_HWCAP2_SHA1}, "sha1", &set_sha1}, // [ARM_SHA1] = {{0, ARM_HWCAP2_SHA1}, "sha1", &set_sha1}, //
{{0, ARM_HWCAP2_SHA2}, "sha2", &set_sha2}, // [ARM_SHA2] = {{0, ARM_HWCAP2_SHA2}, "sha2", &set_sha2}, //
{{0, ARM_HWCAP2_CRC32}, "crc32", &set_crc32}, // [ARM_CRC32] = {{0, ARM_HWCAP2_CRC32}, "crc32", &set_crc32}, //
}; };
static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig); static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
@ -285,61 +286,7 @@ int GetArmFeaturesEnumValue(const ArmFeatures* features,
} }
const char* GetArmFeaturesEnumName(ArmFeaturesEnum value) { const char* GetArmFeaturesEnumName(ArmFeaturesEnum value) {
switch (value) { if(value >= kConfigsSize)
case ARM_SWP: return "unknown feature";
return "swp"; return kConfigs[value].proc_cpuinfo_flag;
case ARM_HALF:
return "half";
case ARM_THUMB:
return "thumb";
case ARM_FASTMULT:
return "fastmult";
case ARM_FPA:
return "fpa";
case ARM_VFP:
return "vfp";
case ARM_EDSP:
return "edsp";
case ARM_JAVA:
return "java";
case ARM_IWMMXT:
return "iwmmxt";
case ARM_CRUNCH:
return "crunch";
case ARM_THUMBEE:
return "thumbee";
case ARM_NEON:
return "neon";
case ARM_VFPV3:
return "vfpv3";
case ARM_VFPV3D16:
return "vfpv3d16";
case ARM_TLS:
return "tls";
case ARM_VFPV4:
return "vfpv4";
case ARM_IDIVA:
return "idiva";
case ARM_IDIVT:
return "idivt";
case ARM_VFPD32:
return "vfpd32";
case ARM_LPAE:
return "lpae";
case ARM_EVTSTRM:
return "evtstrm";
case ARM_AES:
return "aes";
case ARM_PMULL:
return "pmull";
case ARM_SHA1:
return "sha1";
case ARM_SHA2:
return "sha2";
case ARM_CRC32:
return "crc32";
case ARM_LAST_:
break;
}
return "unknown feature";
} }

24
src/cpuinfo_mips.c
View File

@ -19,14 +19,16 @@
#include "internal/string_view.h" #include "internal/string_view.h"
#include "internal/unix_features_aggregator.h" #include "internal/unix_features_aggregator.h"
#include <assert.h>
DECLARE_SETTER(MipsFeatures, msa) DECLARE_SETTER(MipsFeatures, msa)
DECLARE_SETTER(MipsFeatures, eva) DECLARE_SETTER(MipsFeatures, eva)
DECLARE_SETTER(MipsFeatures, r6) DECLARE_SETTER(MipsFeatures, r6)
static const CapabilityConfig kConfigs[] = { static const CapabilityConfig kConfigs[] = {
{{MIPS_HWCAP_MSA, 0}, "msa", &set_msa}, // [MIPS_MSA] = {{MIPS_HWCAP_MSA, 0}, "msa", &set_msa}, //
{{0, 0}, "eva", &set_eva}, // [MIPS_EVA] = {{0, 0}, "eva", &set_eva}, //
{{MIPS_HWCAP_R6, 0}, "r6", &set_r6}, // [MIPS_R6] = {{MIPS_HWCAP_R6, 0}, "r6", &set_r6}, //
}; };
static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig); static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
@ -59,6 +61,8 @@ static void FillProcCpuInfoData(MipsFeatures* const features) {
static const MipsInfo kEmptyMipsInfo; static const MipsInfo kEmptyMipsInfo;
MipsInfo GetMipsInfo(void) { MipsInfo GetMipsInfo(void) {
assert(kConfigsSize == MIPS_LAST_);
// capabilities are fetched from both getauxval and /proc/cpuinfo so we can // capabilities are fetched from both getauxval and /proc/cpuinfo so we can
// have some information if the executable is sandboxed (aka no access to // have some information if the executable is sandboxed (aka no access to
// /proc/cpuinfo). // /proc/cpuinfo).
@ -90,15 +94,7 @@ int GetMipsFeaturesEnumValue(const MipsFeatures* features,
} }
const char* GetMipsFeaturesEnumName(MipsFeaturesEnum value) { const char* GetMipsFeaturesEnumName(MipsFeaturesEnum value) {
switch (value) { if(value >= kConfigsSize)
case MIPS_MSA: return "unknown feature";
return "msa"; return kConfigs[value].proc_cpuinfo_flag;
case MIPS_EVA:
return "eva";
case MIPS_R6:
return "r6";
case MIPS_LAST_:
break;
}
return "unknown feature";
} }

173
src/cpuinfo_ppc.c
View File

@ -12,6 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
#include <assert.h>
#include <stdbool.h> #include <stdbool.h>
#include <string.h> #include <string.h>
@ -65,49 +66,49 @@ DECLARE_SETTER(PPCFeatures, scv)
DECLARE_SETTER(PPCFeatures, htm_no_suspend) DECLARE_SETTER(PPCFeatures, htm_no_suspend)
static const CapabilityConfig kConfigs[] = { static const CapabilityConfig kConfigs[] = {
{{PPC_FEATURE_32, 0}, "ppc32", &set_ppc32}, [PPC_32] = {{PPC_FEATURE_32, 0}, "ppc32", &set_ppc32},
{{PPC_FEATURE_64, 0}, "ppc64", &set_ppc64}, [PPC_64] = {{PPC_FEATURE_64, 0}, "ppc64", &set_ppc64},
{{PPC_FEATURE_601_INSTR, 0}, "ppc601", &set_ppc601}, [PPC_601_INSTR] = {{PPC_FEATURE_601_INSTR, 0}, "ppc601", &set_ppc601},
{{PPC_FEATURE_HAS_ALTIVEC, 0}, "altivec", &set_altivec}, [PPC_HAS_ALTIVEC] = {{PPC_FEATURE_HAS_ALTIVEC, 0}, "altivec", &set_altivec},
{{PPC_FEATURE_HAS_FPU, 0}, "fpu", &set_fpu}, [PPC_HAS_FPU] = {{PPC_FEATURE_HAS_FPU, 0}, "fpu", &set_fpu},
{{PPC_FEATURE_HAS_MMU, 0}, "mmu", &set_mmu}, [PPC_HAS_MMU] = {{PPC_FEATURE_HAS_MMU, 0}, "mmu", &set_mmu},
{{PPC_FEATURE_HAS_4xxMAC, 0}, "4xxmac", &set_mac_4xx}, [PPC_HAS_4xxMAC] = {{PPC_FEATURE_HAS_4xxMAC, 0}, "4xxmac", &set_mac_4xx},
{{PPC_FEATURE_UNIFIED_CACHE, 0}, "ucache", &set_unifiedcache}, [PPC_UNIFIED_CACHE] = {{PPC_FEATURE_UNIFIED_CACHE, 0}, "ucache", &set_unifiedcache},
{{PPC_FEATURE_HAS_SPE, 0}, "spe", &set_spe}, [PPC_HAS_SPE] = {{PPC_FEATURE_HAS_SPE, 0}, "spe", &set_spe},
{{PPC_FEATURE_HAS_EFP_SINGLE, 0}, "efpsingle", &set_efpsingle}, [PPC_HAS_EFP_SINGLE] = {{PPC_FEATURE_HAS_EFP_SINGLE, 0}, "efpsingle", &set_efpsingle},
{{PPC_FEATURE_HAS_EFP_DOUBLE, 0}, "efpdouble", &set_efpdouble}, [PPC_HAS_EFP_DOUBLE] = {{PPC_FEATURE_HAS_EFP_DOUBLE, 0}, "efpdouble", &set_efpdouble},
{{PPC_FEATURE_NO_TB, 0}, "notb", &set_no_tb}, [PPC_NO_TB] = {{PPC_FEATURE_NO_TB, 0}, "notb", &set_no_tb},
{{PPC_FEATURE_POWER4, 0}, "power4", &set_power4}, [PPC_POWER4] = {{PPC_FEATURE_POWER4, 0}, "power4", &set_power4},
{{PPC_FEATURE_POWER5, 0}, "power5", &set_power5}, [PPC_POWER5] = {{PPC_FEATURE_POWER5, 0}, "power5", &set_power5},
{{PPC_FEATURE_POWER5_PLUS, 0}, "power5+", &set_power5plus}, [PPC_POWER5_PLUS] = {{PPC_FEATURE_POWER5_PLUS, 0}, "power5+", &set_power5plus},
{{PPC_FEATURE_CELL, 0}, "cellbe", &set_cell}, [PPC_CELL] = {{PPC_FEATURE_CELL, 0}, "cellbe", &set_cell},
{{PPC_FEATURE_BOOKE, 0}, "booke", &set_booke}, [PPC_BOOKE] = {{PPC_FEATURE_BOOKE, 0}, "booke", &set_booke},
{{PPC_FEATURE_SMT, 0}, "smt", &set_smt}, [PPC_SMT] = {{PPC_FEATURE_SMT, 0}, "smt", &set_smt},
{{PPC_FEATURE_ICACHE_SNOOP, 0}, "ic_snoop", &set_icachesnoop}, [PPC_ICACHE_SNOOP] = {{PPC_FEATURE_ICACHE_SNOOP, 0}, "ic_snoop", &set_icachesnoop},
{{PPC_FEATURE_ARCH_2_05, 0}, "arch_2_05", &set_arch205}, [PPC_ARCH_2_05] = {{PPC_FEATURE_ARCH_2_05, 0}, "arch_2_05", &set_arch205},
{{PPC_FEATURE_PA6T, 0}, "pa6t", &set_pa6t}, [PPC_PA6T] = {{PPC_FEATURE_PA6T, 0}, "pa6t", &set_pa6t},
{{PPC_FEATURE_HAS_DFP, 0}, "dfp", &set_dfp}, [PPC_HAS_DFP] = {{PPC_FEATURE_HAS_DFP, 0}, "dfp", &set_dfp},
{{PPC_FEATURE_POWER6_EXT, 0}, "power6x", &set_power6ext}, [PPC_POWER6_EXT] = {{PPC_FEATURE_POWER6_EXT, 0}, "power6x", &set_power6ext},
{{PPC_FEATURE_ARCH_2_06, 0}, "arch_2_06", &set_arch206}, [PPC_ARCH_2_06] = {{PPC_FEATURE_ARCH_2_06, 0}, "arch_2_06", &set_arch206},
{{PPC_FEATURE_HAS_VSX, 0}, "vsx", &set_vsx}, [PPC_HAS_VSX] = {{PPC_FEATURE_HAS_VSX, 0}, "vsx", &set_vsx},
{{PPC_FEATURE_PSERIES_PERFMON_COMPAT, 0}, [PPC_PSERIES_PERFMON_COMPAT] = {{PPC_FEATURE_PSERIES_PERFMON_COMPAT, 0},
"archpmu", "archpmu",
&set_pseries_perfmon_compat}, &set_pseries_perfmon_compat},
{{PPC_FEATURE_TRUE_LE, 0}, "true_le", &set_truele}, [PPC_TRUE_LE] = {{PPC_FEATURE_TRUE_LE, 0}, "true_le", &set_truele},
{{PPC_FEATURE_PPC_LE, 0}, "ppcle", &set_ppcle}, [PPC_PPC_LE] = {{PPC_FEATURE_PPC_LE, 0}, "ppcle", &set_ppcle},
{{0, PPC_FEATURE2_ARCH_2_07}, "arch_2_07", &set_arch207}, [PPC_ARCH_2_07] = {{0, PPC_FEATURE2_ARCH_2_07}, "arch_2_07", &set_arch207},
{{0, PPC_FEATURE2_HTM}, "htm", &set_htm}, [PPC_HTM] = {{0, PPC_FEATURE2_HTM}, "htm", &set_htm},
{{0, PPC_FEATURE2_DSCR}, "dscr", &set_dscr}, [PPC_DSCR] = {{0, PPC_FEATURE2_DSCR}, "dscr", &set_dscr},
{{0, PPC_FEATURE2_EBB}, "ebb", &set_ebb}, [PPC_EBB] = {{0, PPC_FEATURE2_EBB}, "ebb", &set_ebb},
{{0, PPC_FEATURE2_ISEL}, "isel", &set_isel}, [PPC_ISEL] = {{0, PPC_FEATURE2_ISEL}, "isel", &set_isel},
{{0, PPC_FEATURE2_TAR}, "tar", &set_tar}, [PPC_TAR] = {{0, PPC_FEATURE2_TAR}, "tar", &set_tar},
{{0, PPC_FEATURE2_VEC_CRYPTO}, "vcrypto", &set_vcrypto}, [PPC_VEC_CRYPTO] = {{0, PPC_FEATURE2_VEC_CRYPTO}, "vcrypto", &set_vcrypto},
{{0, PPC_FEATURE2_HTM_NOSC}, "htm-nosc", &set_htm_nosc}, [PPC_HTM_NOSC] = {{0, PPC_FEATURE2_HTM_NOSC}, "htm-nosc", &set_htm_nosc},
{{0, PPC_FEATURE2_ARCH_3_00}, "arch_3_00", &set_arch300}, [PPC_ARCH_3_00] = {{0, PPC_FEATURE2_ARCH_3_00}, "arch_3_00", &set_arch300},
{{0, PPC_FEATURE2_HAS_IEEE128}, "ieee128", &set_ieee128}, [PPC_HAS_IEEE128] = {{0, PPC_FEATURE2_HAS_IEEE128}, "ieee128", &set_ieee128},
{{0, PPC_FEATURE2_DARN}, "darn", &set_darn}, [PPC_DARN] = {{0, PPC_FEATURE2_DARN}, "darn", &set_darn},
{{0, PPC_FEATURE2_SCV}, "scv", &set_scv}, [PPC_SCV] = {{0, PPC_FEATURE2_SCV}, "scv", &set_scv},
{{0, PPC_FEATURE2_HTM_NO_SUSPEND}, "htm-no-suspend", &set_htm_no_suspend}, [PPC_HTM_NO_SUSPEND] = {{0, PPC_FEATURE2_HTM_NO_SUSPEND}, "htm-no-suspend", &set_htm_no_suspend},
}; };
static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig); static const size_t kConfigsSize = sizeof(kConfigs) / sizeof(CapabilityConfig);
@ -268,91 +269,7 @@ int GetPPCFeaturesEnumValue(const PPCFeatures* features,
/* Have used the same names as glibc */ /* Have used the same names as glibc */
const char* GetPPCFeaturesEnumName(PPCFeaturesEnum value) { const char* GetPPCFeaturesEnumName(PPCFeaturesEnum value) {
switch (value) { if(value >= kConfigsSize)
case PPC_32: return "unknown feature";
return "ppc32"; return kConfigs[value].proc_cpuinfo_flag;
case PPC_64:
return "ppc64";
case PPC_601_INSTR:
return "ppc601";
case PPC_HAS_ALTIVEC:
return "altivec";
case PPC_HAS_FPU:
return "fpu";
case PPC_HAS_MMU:
return "mmu";
case PPC_HAS_4xxMAC:
return "4xxmac";
case PPC_UNIFIED_CACHE:
return "ucache";
case PPC_HAS_SPE:
return "spe";
case PPC_HAS_EFP_SINGLE:
return "efpsingle";
case PPC_HAS_EFP_DOUBLE:
return "efpdouble";
case PPC_NO_TB:
return "notb";
case PPC_POWER4:
return "power4";
case PPC_POWER5:
return "power5";
case PPC_POWER5_PLUS:
return "power5+";
case PPC_CELL:
return "cellbe";
case PPC_BOOKE:
return "booke";
case PPC_SMT:
return "smt";
case PPC_ICACHE_SNOOP:
return "ic_snoop";
case PPC_ARCH_2_05:
return "arch_2_05";
case PPC_PA6T:
return "pa6t";
case PPC_HAS_DFP:
return "dfp";
case PPC_POWER6_EXT:
return "power6x";
case PPC_ARCH_2_06:
return "arch_2_06";
case PPC_HAS_VSX:
return "vsx";
case PPC_PSERIES_PERFMON_COMPAT:
return "archpmu";
case PPC_TRUE_LE:
return "true_le";
case PPC_PPC_LE:
return "ppcle";
case PPC_ARCH_2_07:
return "arch_2_07";
case PPC_HTM:
return "htm";
case PPC_DSCR:
return "dscr";
case PPC_EBB:
return "ebb";
case PPC_ISEL:
return "isel";
case PPC_TAR:
return "tar";
case PPC_VEC_CRYPTO:
return "vcrypto";
case PPC_HTM_NOSC:
return "htm-nosc";
case PPC_ARCH_3_00:
return "arch_3_00";
case PPC_HAS_IEEE128:
return "ieee128";
case PPC_DARN:
return "darn";
case PPC_SCV:
return "scv";
case PPC_HTM_NO_SUSPEND:
return "htm-no-suspend";
case PPC_LAST_:
break;
}
return "unknown_feature";
} }